From d593bd2bbf0fdf9e5aa44cf4ccd6349b9f6b3a01 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 4 Aug 2026 17:37:32 -0500 Subject: [PATCH 001/115] Register the GSP codecs settings and servlet without live instances filteringCodecsByContentTypeSettings took the live GrailsApplication as a constructor argument, and groovyPagesServlet took a new GroovyPagesServlet(). Spring AOT's ValueCodeGenerator cannot emit code for an arbitrary object, so processAot aborted the entire run: UnsupportedTypeValueCodeGenerationException: Code generation does not support grails.core.DefaultGrailsApplication Both now use forms the generator understands: a reference by bean name, as errorsViewStackTracePrinter directly above already does, and an inner bean definition. This was the first processAot failure for a stock web application on 7.2.1, 8.0.0-M4 and 8.0.0-SNAPSHOT alike. Further blockers remain behind it, so this does not by itself make an application AOT-processable. Constructing the servlet through the registry rather than with new means it now passes through bean post-processing. Its pluginManager is unaffected - initFrameworkServlet already autowires the servlet's properties by type, which covers that setter - but a post-processor whose pointcut matched the servlet would hand ServletRegistrationBean a proxy in its place. No pointcut in the framework does. --- .../org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index 3d1b0ae61b6..f3a08dbe0a1 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -265,9 +265,9 @@ class GroovyPagesGrailsPlugin extends Plugin { } errorsViewStackTracePrinter(ErrorsViewStackTracePrinter, ref('grailsResourceLocator')) - filteringCodecsByContentTypeSettings(FilteringCodecsByContentTypeSettings, application) + filteringCodecsByContentTypeSettings(FilteringCodecsByContentTypeSettings, ref('grailsApplication')) - groovyPagesServlet(ServletRegistrationBean, new GroovyPagesServlet(), '*.gsp') { + groovyPagesServlet(ServletRegistrationBean, bean(GroovyPagesServlet), '*.gsp') { if (Environment.isDevelopmentMode()) { initParameters = [showSource: '1'] } From ff515d199aa142184ba62226a1ef4fa5afbd242e Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 4 Aug 2026 17:47:29 -0500 Subject: [PATCH 002/115] Do not add a ConfigurationClassPostProcessor to an AOT context CoreGrailsPlugin registers a second ConfigurationClassPostProcessor so that @Configuration beans contributed by plugins through doWithSpring - which arrive after Spring's own processor has finished - still get parsed. An AOT-optimized context has no ConfigurationClassPostProcessor at all: the configuration classes were parsed at build time and their bean definitions are in the generated initializer. Registering one there parses them a second time, and the re-parse collides with what AOT already emitted: BeanDefinitionStoreException: Invalid bean definition with name 'propertySourcesPlaceholderConfigurer' defined in org.grails.plugins.CoreAutoConfiguration: Bean name derived from @Bean method 'propertySourcesPlaceholderConfigurer' clashes with bean name for containing configuration class For a static @Bean method AOT emits the bean definition with the configuration class as its bean class, so the re-parse rediscovers CoreAutoConfiguration under the bean name propertySourcesPlaceholderConfigurer and then collides with itself. The processor is skipped when AotDetector.useGeneratedArtifacts() reports generated artifacts are in use; behaviour without AOT is unchanged. This was reachable only after the GSP live-instance beans were fixed, since processAot did not previously get far enough to produce an initializer. --- .../groovy/org/grails/plugins/CoreGrailsPlugin.groovy | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy index c65796ecde2..3824e08ff2f 100644 --- a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy +++ b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy @@ -21,6 +21,7 @@ package org.grails.plugins import groovy.transform.CompileStatic import org.springframework.aop.config.AopConfigUtils +import org.springframework.aot.AotDetector import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.BeanRegistry import org.springframework.beans.factory.config.CustomEditorConfigurer @@ -129,8 +130,13 @@ class CoreGrailsPlugin extends Plugin { GrailsApplication application = grailsApplication Config config = application.config - // enable post-processing of @Configuration beans defined by plugins - registry.registerBean('grailsConfigurationClassPostProcessor', ConfigurationClassPostProcessor) + // enable post-processing of @Configuration beans defined by plugins. An AOT-optimized + // context has no ConfigurationClassPostProcessor of its own: the configuration classes + // were parsed at build time and their beans are already in the generated initializer, + // so registering one here would parse them a second time. + if (!AotDetector.useGeneratedArtifacts()) { + registry.registerBean('grailsConfigurationClassPostProcessor', ConfigurationClassPostProcessor) + } registry.registerBean('grailsBeanOverrideConfigurer', MapBasedSmartPropertyOverrideConfigurer) { it.supplier { From 38e941fecd6b60daa347eab6b1926fec2d649848 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 4 Aug 2026 18:12:40 -0500 Subject: [PATCH 003/115] Keep abstract bean definitions out of AOT processing An abstract bean definition is a template: it carries property values for children to inherit and is never instantiated. Spring's bean-definition code generator has no representation for one - BeanDefinitionPropertiesCodeGenerator emits lazyInit, primary, scope, role and synthetic, but not the abstract flag, and nothing filters abstract definitions out beforehand. The definition is regenerated as a concrete bean of type Object still carrying the template's properties, and the context fails applying them: BeanCreationException: Error creating bean with name 'abstractGrailsResourceLocator': Invalid property 'searchLocations' of bean class [java.lang.Object] CoreGrailsPlugin contributes exactly such a template through AbstractResourceLocatorPostProcessor, and it is public surface - third-party plugins inherit from it with bean.parent, asset-pipeline's assetResourceLocator among them - so it cannot simply be removed. A BeanRegistrationExcludeFilter registered in META-INF/spring/aot.factories keeps every abstract definition out of generation. Children are unaffected, because AOT generates them from their merged definition with inherited values already folded in; a definition contributed dynamically still finds its parent, since the post-processor that registers the template runs during refresh in an AOT context as it does in any other. With this an AOT-processed application starts. Its bean definitions differ from a normal boot only by the annotation-processing infrastructure AOT replaces: the configuration, autowired and common-annotation processors, Boot's shared metadata reader factory, and grailsConfigurationClassPostProcessor. --- .../AbstractBeanDefinitionExcludeFilter.java | 48 +++++++++++ .../resources/META-INF/spring/aot.factories | 2 + ...ractBeanDefinitionExcludeFilterSpec.groovy | 79 +++++++++++++++++++ 3 files changed, 129 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java create mode 100644 grails-core/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java new file mode 100644 index 00000000000..58808c10676 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java @@ -0,0 +1,48 @@ +/* + * 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.grails.spring.beans.aot; + +import org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter; +import org.springframework.beans.factory.support.RegisteredBean; + +/** + * Keeps abstract bean definitions out of ahead-of-time processing. + * + *

An abstract definition is a template: it carries property values for children to inherit + * and is never instantiated. Spring's bean-definition code generator has no representation for + * that — it emits neither the abstract flag nor a bean class, so the definition is regenerated + * as a concrete bean of type {@code Object} carrying the template's properties, which fails as + * soon as the context applies them.

+ * + *

Children are unaffected: ahead-of-time processing generates them from their merged + * definition, so inherited values are already folded in and no parent is needed at runtime. + * A definition contributed dynamically still finds its parent, because the post-processor that + * registers the template runs during refresh in an ahead-of-time context as it does in any other.

+ * + * @since 8.0 + * @see org.grails.spring.beans.AbstractResourceLocatorPostProcessor + */ +public class AbstractBeanDefinitionExcludeFilter implements BeanRegistrationExcludeFilter { + + @Override + public boolean isExcludedFromAotProcessing(RegisteredBean registeredBean) { + return registeredBean.getMergedBeanDefinition().isAbstract(); + } + +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..2b6b9870fe9 --- /dev/null +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter=\ +org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy new file mode 100644 index 00000000000..c0b0ee9de52 --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy @@ -0,0 +1,79 @@ +/* + * 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.grails.spring.beans.aot + +import spock.lang.Specification + +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.beans.factory.support.GenericBeanDefinition +import org.springframework.beans.factory.support.RegisteredBean + +import org.grails.spring.beans.AbstractResourceLocatorPostProcessor + +class AbstractBeanDefinitionExcludeFilterSpec extends Specification { + + DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory() + AbstractBeanDefinitionExcludeFilter filter = new AbstractBeanDefinitionExcludeFilter() + + void 'an abstract definition is excluded from AOT processing'() { + given: 'a classless template definition carrying only inherited property values' + def definition = new GenericBeanDefinition() + definition.abstract = true + definition.propertyValues.add('searchLocations', ['/some/location']) + beanFactory.registerBeanDefinition('abstractParent', definition) + + expect: + filter.isExcludedFromAotProcessing(RegisteredBean.of(beanFactory, 'abstractParent')) + } + + void 'a concrete definition is left to AOT processing'() { + given: + def definition = new GenericBeanDefinition() + definition.beanClass = String + beanFactory.registerBeanDefinition('concrete', definition) + + expect: + !filter.isExcludedFromAotProcessing(RegisteredBean.of(beanFactory, 'concrete')) + } + + void 'a child inheriting from an abstract parent is left to AOT processing'() { + given: 'the parent template and a child naming it' + def parent = new GenericBeanDefinition() + parent.abstract = true + parent.propertyValues.add('searchLocations', ['/some/location']) + beanFactory.registerBeanDefinition('abstractParent', parent) + + def child = new GenericBeanDefinition() + child.beanClass = StringBuilder + child.parentName = 'abstractParent' + beanFactory.registerBeanDefinition('child', child) + + expect: 'the child is generated from its merged definition, so it needs no parent at runtime' + !filter.isExcludedFromAotProcessing(RegisteredBean.of(beanFactory, 'child')) + } + + void 'the resource locator template the core plugin contributes is excluded'() { + given: + new AbstractResourceLocatorPostProcessor(['/base']).postProcessBeanDefinitionRegistry(beanFactory) + + expect: + filter.isExcludedFromAotProcessing( + RegisteredBean.of(beanFactory, AbstractResourceLocatorPostProcessor.BEAN_NAME)) + } +} From b3811adb7565c0790d7b3fa8af1d887442ac1372 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 4 Aug 2026 18:30:37 -0500 Subject: [PATCH 004/115] Let the container supply the SiteMesh view resolver's servlet context SiteMeshViewResolver now implements ServletContextAware, so the bean-definition wrap no longer passes the servlet context as a constructor argument. That reference was to a bean the container only registers once the web server has started, which has no bean definition for AOT to resolve, and it failed processAot for every application with GSP on the classpath: AotBeanProcessingException: Error processing bean with name 'jspViewResolver' Caused by: NoSuchBeanDefinitionException: No bean named 'servletContext' available GrailsSiteMeshViewResolver gains the matching three-argument constructor and reads the context through the inherited accessor rather than keeping its own copy. The four-argument constructor stays for callers that build the resolver directly, which is how the instance-level post-processor still creates it. This was the last blocker: a stock Grails web application now completes processAot and starts with spring.aot.enabled=true. Its bean definitions differ from a normal boot only by the annotation-processing infrastructure AOT replaces - the configuration, autowired and common-annotation processors, Boot's shared metadata reader factory, and grailsConfigurationClassPostProcessor. The sitemesh version is moved to 3.3.0-SNAPSHOT because the change it depends on is not in 3.3.0-M3. It must be pinned to a released version before this merges. --- dependencies.gradle | 4 ++-- .../sitemesh3/GrailsSiteMeshViewResolver.java | 12 +++++++++--- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/dependencies.gradle b/dependencies.gradle index 29bc2978822..ad18672d592 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -126,8 +126,8 @@ ext { 'sitemesh.version' : '2.6.0', 'scribejava.version' : '8.3.3', 'spock.version' : '2.4-groovy-5.0', - 'starter-sitemesh.version' : '3.3.0-M3', - 'spring-webmvc-sitemesh.version': '3.3.0-M3', + 'starter-sitemesh.version' : '3.3.0-SNAPSHOT', + 'spring-webmvc-sitemesh.version': '3.3.0-SNAPSHOT', // Spring Boot 4 no longer manages spring-retry; pin it here so the // grails-shell-cli SpringRetryCompilerAutoConfiguration's unversioned // reference resolves and consumer apps using @Retryable get a known version. diff --git a/grails-gsp/grails-sitemesh3/src/main/java/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolver.java b/grails-gsp/grails-sitemesh3/src/main/java/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolver.java index a537f3df971..7b6b38d50c2 100644 --- a/grails-gsp/grails-sitemesh3/src/main/java/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolver.java +++ b/grails-gsp/grails-sitemesh3/src/main/java/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolver.java @@ -37,7 +37,14 @@ public class GrailsSiteMeshViewResolver extends SiteMeshViewResolver { private final ContentProcessor contentProcessor; private final DecoratorSelector decoratorSelector; - private final ServletContext servletContext; + + public GrailsSiteMeshViewResolver(ViewResolver innerViewResolver, + ContentProcessor contentProcessor, + DecoratorSelector decoratorSelector) { + super(innerViewResolver, contentProcessor, decoratorSelector); + this.contentProcessor = contentProcessor; + this.decoratorSelector = decoratorSelector; + } public GrailsSiteMeshViewResolver(ViewResolver innerViewResolver, ContentProcessor contentProcessor, @@ -46,7 +53,6 @@ public GrailsSiteMeshViewResolver(ViewResolver innerViewResolver, super(innerViewResolver, contentProcessor, decoratorSelector, servletContext); this.contentProcessor = contentProcessor; this.decoratorSelector = decoratorSelector; - this.servletContext = servletContext; } @Override @@ -54,7 +60,7 @@ protected SiteMeshView createSiteMeshView(View innerView) { // Forward-based JSP inner views are switched to include dispatch by // SiteMeshViewResolver.prepareForBufferedRender (keyed on // DispatchMode) before this hook runs. - return new GrailsSiteMeshView(innerView, contentProcessor, decoratorSelector, servletContext, + return new GrailsSiteMeshView(innerView, contentProcessor, decoratorSelector, getServletContext(), getInnerViewResolver()); } } From bc537807e332ba021f6a332a51bc63f7418c724a Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 4 Aug 2026 19:34:58 -0500 Subject: [PATCH 005/115] Document ahead-of-time processing and cover it with tests AOT support is opt-in and needs configuration that is not guessable - the Spring Boot AOT plugin, and generation in production mode, without which the url mappings holder takes its reload-mode proxy shape and generation fails naming a bean unrelated to anything in the application. The deployment guide now covers enabling it, what changes at runtime, and the limitations: registrar-contributed beans are not generated, definitions holding live objects cannot be generated, abstract definitions are excluded, and AOT alone does not make an application native-image ready. Two layers of coverage, because the failures differ in kind. CoreGrailsPluginAotSpec runs the real generator over the core plugin's bean definitions, so a definition holding a live instance fails the build. It also covers the configuration class post-processor being registered normally and withheld when generated artifacts are in use, which no existing test reached. A fourth case registers a definition holding a live instance and asserts generation rejects it, so the check above cannot pass vacuously. Generation succeeding does not mean the application starts, and the post-processor condition is a runtime-only behaviour. The grails-test-examples aot application therefore runs processAot and then starts the packaged jar with spring.aot.enabled=true, asserting the beans an AOT context must still contain. Its check task fails the build if either half regresses. --- .../plugins/CoreGrailsPluginAotSpec.groovy | 146 ++++++++++++++++++ .../en/guide/deployment/deploymentAot.adoc | 101 ++++++++++++ grails-doc/src/en/guide/toc.yml | 1 + ...eMeshViewResolverServletContextSpec.groovy | 105 +++++++++++++ grails-test-examples/aot/build.gradle | 71 +++++++++ .../aot/grails-app/conf/application.yml | 5 + .../grails-app/init/aot/Application.groovy | 59 +++++++ settings.gradle | 2 + 8 files changed, 490 insertions(+) create mode 100644 grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy create mode 100644 grails-doc/src/en/guide/deployment/deploymentAot.adoc create mode 100644 grails-gsp/grails-sitemesh3/src/test/groovy/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolverServletContextSpec.groovy create mode 100644 grails-test-examples/aot/build.gradle create mode 100644 grails-test-examples/aot/grails-app/conf/application.yml create mode 100644 grails-test-examples/aot/grails-app/init/aot/Application.groovy diff --git a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy new file mode 100644 index 00000000000..84ce4e450fc --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy @@ -0,0 +1,146 @@ +/* + * 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.grails.plugins + +import org.springframework.aot.AotDetector +import org.springframework.aot.generate.ClassNameGenerator +import org.springframework.aot.generate.DefaultGenerationContext +import org.springframework.aot.generate.InMemoryGeneratedFiles +import org.springframework.beans.factory.BeanRegistrar +import org.springframework.beans.factory.support.BeanRegistryAdapter +import org.springframework.beans.factory.support.GenericBeanDefinition +import org.springframework.context.aot.ApplicationContextAotGenerator +import org.springframework.context.support.GenericApplicationContext +import org.springframework.core.SpringProperties +import org.springframework.javapoet.ClassName + +import grails.core.DefaultGrailsApplication +import grails.core.GrailsApplication +import grails.plugins.DefaultGrailsPluginManager +import grails.plugins.GrailsPlugin +import grails.plugins.GrailsPluginManager +import org.apache.grails.core.plugins.DefaultPluginDiscovery +import spock.lang.Specification + +/** + * Covers the core plugin's behaviour under Spring's ahead-of-time processing: the bean definitions + * it contributes must be expressible as generated code, and the configuration class post-processor + * it registers must stand down where the context already has its bean definitions generated. + */ +class CoreGrailsPluginAotSpec extends Specification { + + GenericApplicationContext context = new GenericApplicationContext() + + void cleanup() { + SpringProperties.setProperty(AotDetector.AOT_ENABLED, null) + context.close() + } + + /** + * Mirrors the registrar phase of {@code GrailsApplicationPostProcessor}: every enabled plugin's + * {@link BeanRegistrar} applied against the registry through the same adapter the runtime uses. + */ + private void applyCorePluginRegistrar() { + GrailsApplication application = new DefaultGrailsApplication() + application.applicationContext = context + application.initialise() + + def discovery = new DefaultPluginDiscovery([CoreGrailsPlugin] as Class[]) + discovery.loadPluginsFromClasspath = false + discovery.init(context.environment) + + GrailsPluginManager pluginManager = new DefaultGrailsPluginManager(application, discovery) + context.beanFactory.registerSingleton(GrailsApplication.APPLICATION_ID, application) + context.beanFactory.registerSingleton(GrailsPluginManager.BEAN_NAME, pluginManager) + pluginManager.loadPlugins() + + for (GrailsPlugin plugin : pluginManager.allPlugins) { + BeanRegistrar registrar = plugin.beanRegistrar + if (registrar != null) { + new BeanRegistryAdapter(context, context, context.environment, registrar.getClass()) + .register(registrar) + } + } + } + + void 'the configuration class post-processor is registered when generated artifacts are not in use'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + + when: + applyCorePluginRegistrar() + + then: 'plugin-contributed @Configuration beans still need parsing at runtime' + context.containsBeanDefinition('grailsConfigurationClassPostProcessor') + } + + void 'the configuration class post-processor is withheld when generated artifacts are in use'() { + given: 'the flag an AOT-optimized application is started with' + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'true') + + when: + applyCorePluginRegistrar() + + then: 'the configuration classes were parsed at build time, so parsing them again would ' + + 'collide with the definitions already generated' + !context.containsBeanDefinition('grailsConfigurationClassPostProcessor') + } + + void 'the core plugin bean definitions can be generated ahead of time'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + applyCorePluginRegistrar() + + and: + def generationContext = new DefaultGenerationContext( + new ClassNameGenerator(ClassName.get('org.grails.aot.test', 'CoreAotTest')), + new InMemoryGeneratedFiles()) + + when: 'the context is processed exactly as the processAot build task processes it' + new ApplicationContextAotGenerator().processAheadOfTime(context, generationContext) + + then: 'no definition holds a value the generator cannot express as code -- a live instance ' + + 'passed as a constructor argument or property value would fail here' + noExceptionThrown() + } + + void 'a definition holding a live instance fails generation'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + applyCorePluginRegistrar() + + and: 'the shape this plugin must avoid: an already-constructed object as a constructor argument' + def definition = new GenericBeanDefinition() + definition.beanClass = StringBuilder + definition.constructorArgumentValues.addIndexedArgumentValue(0, new DefaultGrailsApplication()) + context.registerBeanDefinition('holdsALiveInstance', definition) + + and: + def generationContext = new DefaultGenerationContext( + new ClassNameGenerator(ClassName.get('org.grails.aot.test', 'LiveInstanceAotTest')), + new InMemoryGeneratedFiles()) + + when: + new ApplicationContextAotGenerator().processAheadOfTime(context, generationContext) + + then: 'proving the preceding check is capable of failing' + Exception e = thrown() + e.message.contains('holdsALiveInstance') + } +} diff --git a/grails-doc/src/en/guide/deployment/deploymentAot.adoc b/grails-doc/src/en/guide/deployment/deploymentAot.adoc new file mode 100644 index 00000000000..1a902b20a58 --- /dev/null +++ b/grails-doc/src/en/guide/deployment/deploymentAot.adoc @@ -0,0 +1,101 @@ +//// +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. +//// + +Spring's ahead-of-time (AOT) processing moves bean wiring from startup to build time. Instead of scanning the classpath, reading annotations and evaluating conditions on every boot, the build generates Java source that registers the bean definitions directly, and the application runs that. + +Two things follow from it: startup does less work, and the application becomes eligible for a GraalVM native image, which cannot perform the classpath scanning and reflection that normal startup relies on. + +AOT is opt-in. + + +=== Enabling AOT + + +Apply the Spring Boot AOT plugin alongside the Grails plugins: + +[source,groovy] +---- +apply plugin: 'org.springframework.boot.aot' +---- + +This adds a `processAot` task, which `bootJar` then runs as part of the build. Nothing about a normal `bootRun` or `bootJar` changes until the application is started with AOT enabled: + +[source,bash] +---- +java -Dspring.aot.enabled=true -jar build/libs/myapp.jar +---- + +An application started this way logs `Starting AOT-processed Application` rather than `Starting Application`. + + +=== Generate in production mode + + +`processAot` builds the bean definitions that the packaged application will use, so it must run with the same environment those definitions are meant for: + +[source,groovy] +---- +tasks.named('processAot') { + systemProperty 'grails.env', 'production' +} +---- + +Without this the task runs in the development environment, where reloading is enabled and several beans take a different shape. The URL mappings holder, for example, becomes a proxy whose type cannot be determined without creating it, and generation fails with an error naming a bean that is unrelated to anything in the application: + +[source] +---- +Field urlMappings in org.grails.web.mapping.servlet.UrlMappingsErrorPageCustomizer +required a bean of type 'grails.web.mapping.UrlMappings' that could not be found. +---- + +Reload-mode beans have no meaning in a packaged artifact, so generating in production mode is correct as well as necessary. + + +=== What AOT changes at runtime + + +An AOT-processed application registers the same beans as a normal one. The difference is the annotation-processing infrastructure it no longer needs, since the work those components do has already been done: + +* `internalConfigurationAnnotationProcessor` +* `internalAutowiredAnnotationProcessor` +* `internalCommonAnnotationProcessor` +* Spring Boot's shared metadata reader factory +* Grails' own configuration class post-processor + +Application beans, plugin beans and auto-configuration beans are all present as usual. + + +=== Limitations + + +Beans contributed from a plugin's `beanRegistrar()` are not generated. Spring marks them as registrar-owned and skips them, and they are registered again at runtime when Grails applies the plugin registrars. They behave correctly, but the plugin scan that produces them still runs on every start, so they do not benefit from generation. + +Writing bean definitions that hold live objects will fail generation. A definition is a recipe rather than an instance, and there is no general way to generate code that reconstructs an arbitrary object, so a constructor argument or property value holding one cannot be processed: + +[source] +---- +UnsupportedTypeValueCodeGenerationException: + Code generation does not support com.example.SomeService +---- + +Reference another bean by name instead, or express the collaborator as a nested bean definition, and the generator can emit both. + +Abstract bean definitions — templates that exist only to be inherited through `bean.parent` — are excluded from generation, because Spring has no representation for them in generated code. Definitions that inherit from one are unaffected: they are generated from their merged definition, with the inherited values already folded in. + +AOT processing on its own does not make an application ready for a native image. A native image additionally requires reachability metadata covering the resources and reflection an application performs at runtime. diff --git a/grails-doc/src/en/guide/toc.yml b/grails-doc/src/en/guide/toc.yml index b0e4a5c3ff4..6132ebf6094 100644 --- a/grails-doc/src/en/guide/toc.yml +++ b/grails-doc/src/en/guide/toc.yml @@ -393,5 +393,6 @@ deployment: deploymentStandalone: Standalone deploymentContainer: Container Deployment (e.g. Tomcat) deploymentTasks: Deployment Configuration Tasks + deploymentAot: Ahead-of-Time Processing contributing: title: Contributing to Grails diff --git a/grails-gsp/grails-sitemesh3/src/test/groovy/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolverServletContextSpec.groovy b/grails-gsp/grails-sitemesh3/src/test/groovy/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolverServletContextSpec.groovy new file mode 100644 index 00000000000..3cc5b936503 --- /dev/null +++ b/grails-gsp/grails-sitemesh3/src/test/groovy/org/grails/plugins/sitemesh3/GrailsSiteMeshViewResolverServletContextSpec.groovy @@ -0,0 +1,105 @@ +/* + * 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.grails.plugins.sitemesh3 + +import jakarta.servlet.ServletContext + +import org.sitemesh.DecoratorSelector +import org.sitemesh.SiteMeshContext +import org.sitemesh.content.ContentProcessor +import org.sitemesh.content.tagrules.TagBasedContentProcessor +import org.sitemesh.content.tagrules.html.CoreHtmlTagRuleBundle +import org.springframework.beans.factory.support.GenericBeanDefinition +import org.springframework.mock.web.MockServletContext +import org.springframework.web.context.support.GenericWebApplicationContext +import org.springframework.web.servlet.View +import org.springframework.web.servlet.view.InternalResourceViewResolver +import spock.lang.Specification + +/** + * Covers the resolver being built without a servlet context argument and receiving one from the + * container instead. A plain bean factory applies no {@code ServletContextAware} callback, so the + * path only exists in a real web application context. + */ +class GrailsSiteMeshViewResolverServletContextSpec extends Specification { + + MockServletContext servletContext = new MockServletContext() + GenericWebApplicationContext context = new GenericWebApplicationContext(servletContext) + + void setup() { + def target = new GenericBeanDefinition() + target.beanClass = InternalResourceViewResolver + context.registerBeanDefinition('jspViewResolver', target) + + // definitions rather than singletons: the post-processor stands down unless the SiteMesh + // collaborators are present as bean definitions + context.registerBeanDefinition('contentProcessor', + new GenericBeanDefinition(beanClass: CaptureAwareContentProcessor)) + def selector = new GenericBeanDefinition(beanClass: Sitemesh3LayoutFinder, lazyInit: true) + selector.constructorArgumentValues.addIndexedArgumentValue(0, null) + context.registerBeanDefinition('decoratorSelector', selector) + } + + void cleanup() { + context.close() + } + + void 'the rewritten resolver takes its servlet context from the container'() { + given: + new Sitemesh3ViewResolverDefinitionPostProcessor().postProcessBeanDefinitionRegistry(context) + + when: + context.refresh() + + then: 'nothing declares a servletContext bean definition for it to reference' + !context.containsBeanDefinition('servletContext') + + and: + def resolver = context.getBean('jspViewResolver', GrailsSiteMeshViewResolver) + resolver.servletContext.is(servletContext) + } + + void 'the injected servlet context reaches the view the resolver produces'() { + given: + new Sitemesh3ViewResolverDefinitionPostProcessor().postProcessBeanDefinitionRegistry(context) + context.refresh() + + when: 'a view is resolved, which is where the servlet context is read' + def resolver = context.getBean('jspViewResolver', GrailsSiteMeshViewResolver) + View view = resolver.resolveViewName('someView', Locale.ENGLISH) + + then: + view instanceof GrailsSiteMeshView + ((GrailsSiteMeshView) view).servletContext.is(servletContext) + } + + void 'a resolver built with an explicit servlet context still carries it'() { + given: 'the constructor callers outside the container callback use' + ContentProcessor processor = new TagBasedContentProcessor(new CoreHtmlTagRuleBundle()) + DecoratorSelector selector = { content, ctx -> new String[0] } + ServletContext explicit = new MockServletContext() + + when: + def resolver = new GrailsSiteMeshViewResolver( + new InternalResourceViewResolver(), processor, selector, explicit) + + then: + resolver.servletContext.is(explicit) + } +} diff --git a/grails-test-examples/aot/build.gradle b/grails-test-examples/aot/build.gradle new file mode 100644 index 00000000000..18fee968659 --- /dev/null +++ b/grails-test-examples/aot/build.gradle @@ -0,0 +1,71 @@ +/* + * 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 'org.apache.grails.buildsrc.properties' + id 'org.apache.grails.buildsrc.dependency-validator' + id 'org.apache.grails.buildsrc.compile' + id 'org.apache.grails.buildsrc.vulnerability-scan' +} + +version = '0.1' +group = 'functionaltests' + +apply plugin: 'org.apache.grails.gradle.grails-web' +apply plugin: 'org.apache.grails.gradle.grails-gsp' +apply plugin: 'org.springframework.boot.aot' + +apply { + from rootProject.layout.projectDirectory.file('gradle/functional-test-config.gradle') +} + +dependencies { + implementation platform(project(':grails-bom')) + + implementation 'org.apache.grails:grails-dependencies-starter-web' + implementation 'org.apache.grails:grails-sitemesh3' + + testImplementation 'org.apache.grails:grails-testing-support-web' +} + +// Generation reflects the environment the packaged application runs in. Under development, +// reloading is enabled and beans such as the url mappings holder take a proxied shape that has +// no meaning in a packaged artifact and cannot be generated. +tasks.named('processAot') { + systemProperty 'grails.env', 'production' +} + +// The application must also start from what was generated, which is the half that catches a +// runtime-only regression - a context that generates cleanly can still fail to boot. +tasks.register('aotStartupCheck', JavaExec) { + dependsOn tasks.named('bootJar') + group = 'verification' + description = 'Starts the packaged application with AOT enabled and asserts the context comes up' + classpath = files(tasks.named('bootJar').flatMap { it.archiveFile }) + mainClass = 'org.springframework.boot.loader.launch.JarLauncher' + systemProperties([ + 'spring.aot.enabled': 'true', + 'grails.env' : 'production', + ]) + args = ['--aot-startup-check', '--server.port=0', '--spring.main.banner-mode=off'] +} + +tasks.named('check') { + dependsOn tasks.named('aotStartupCheck') +} diff --git a/grails-test-examples/aot/grails-app/conf/application.yml b/grails-test-examples/aot/grails-app/conf/application.yml new file mode 100644 index 00000000000..c6cc7db64ab --- /dev/null +++ b/grails-test-examples/aot/grails-app/conf/application.yml @@ -0,0 +1,5 @@ +grails: + profile: web +info: + app: + name: aot diff --git a/grails-test-examples/aot/grails-app/init/aot/Application.groovy b/grails-test-examples/aot/grails-app/init/aot/Application.groovy new file mode 100644 index 00000000000..e56f66ce0ec --- /dev/null +++ b/grails-test-examples/aot/grails-app/init/aot/Application.groovy @@ -0,0 +1,59 @@ +/* + * 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 aot + +import grails.boot.GrailsApp +import grails.boot.config.GrailsAutoConfiguration + +import org.springframework.context.ConfigurableApplicationContext + +class Application extends GrailsAutoConfiguration { + + /** + * With {@code --aot-startup-check} the application starts, asserts the beans an AOT-processed + * context must still contain, and exits. The build runs it that way against the packaged jar + * with {@code spring.aot.enabled=true}, so a context that generates cleanly but cannot boot + * fails the build rather than passing unnoticed. + */ + static void main(String[] args) { + if (!args.contains('--aot-startup-check')) { + GrailsApp.run(Application, args) + return + } + + ConfigurableApplicationContext context = (ConfigurableApplicationContext) GrailsApp.run(Application, args) + try { + assertBeanPresent(context, 'grailsApplication') + assertBeanPresent(context, 'filteringCodecsByContentTypeSettings') + assertBeanPresent(context, 'groovyPagesServlet') + assertBeanPresent(context, 'jspViewResolver') + assertBeanPresent(context, 'grailsUrlMappingsHolder') + } + finally { + context.close() + } + System.exit(0) + } + + private static void assertBeanPresent(ConfigurableApplicationContext context, String name) { + if (!context.containsBean(name)) { + throw new IllegalStateException("AOT-processed context is missing the '${name}' bean") + } + } +} diff --git a/settings.gradle b/settings.gradle index ac25c7e025f..820ffbe9c3d 100644 --- a/settings.gradle +++ b/settings.gradle @@ -526,6 +526,7 @@ project(':grails-test-examples-redis').projectDir = new File(settingsDir, 'grail // Functional Tests include( + 'grails-test-examples-aot', 'grails-test-examples-app1', 'grails-test-examples-app2', 'grails-test-examples-app3', @@ -573,6 +574,7 @@ include( project(':grails-test-examples-async-events-pubsub-demo').projectDir = file('grails-test-examples/async-events-pubsub-demo') project(':grails-test-examples-beans-dsl').projectDir = file('grails-test-examples/beans-dsl') project(':grails-test-examples-beans-dsl-plugin').projectDir = file('grails-test-examples/beans-dsl-plugin') +project(':grails-test-examples-aot').projectDir = file('grails-test-examples/aot') project(':grails-test-examples-app1').projectDir = file('grails-test-examples/app1') project(':grails-test-examples-app2').projectDir = file('grails-test-examples/app2') project(':grails-test-examples-app3').projectDir = file('grails-test-examples/app3') From 227d74695e74a18514ec6e617b2b88e623f70a87 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 5 Aug 2026 21:09:04 -0700 Subject: [PATCH 006/115] Register the GORM event publisher as a bean definition Spring AOT generates the bean definitions for a context at build time, and it can only do so for beans the container knows how to build. A bean registered as an already-constructed object has nothing to generate from, so the MongoDB datastore could not be processed ahead of time. The MongoDB initializer built the event publisher itself and passed the instance to the datastore constructor. It now registers the publisher as a definition and refers to it by name, so the container builds both. ConfigurableApplicationContextEventPublisher could only be built by passing a context to its constructor, which is the thing a definition cannot do. It now also takes the context from the container through ApplicationContextAware, leaving the existing constructor in place for callers outside a container. Which publisher gets registered still depends on where GORM is being bootstrapped: outside an application context the no-op publisher is used, as before, because the context-aware one would never be given a context there and would fail on the first event it published. --- .../MongoDbDataStoreSpringInitializer.groovy | 20 ++--- ...pringInitializerBeanDefinitionsSpec.groovy | 85 +++++++++++++++++++ ...bleApplicationContextEventPublisher.groovy | 18 +++- ...pplicationContextEventPublisherSpec.groovy | 80 +++++++++++++++++ 4 files changed, 191 insertions(+), 12 deletions(-) create mode 100644 grails-data-mongodb/core/src/test/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializerBeanDefinitionsSpec.groovy create mode 100644 grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy diff --git a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy index 68dfe37d573..48e83448920 100644 --- a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy +++ b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy @@ -22,7 +22,6 @@ import com.mongodb.client.MongoClient import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.context.ApplicationContext -import org.springframework.context.ApplicationEventPublisher import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.support.GenericApplicationContext import org.springframework.util.ClassUtils @@ -89,25 +88,26 @@ class MongoDbDataStoreSpringInitializer extends AbstractDatastoreInitializer { def callable = getCommonConfiguration(beanDefinitionRegistry, 'mongo') callable.delegate = delegate callable.call() - ApplicationEventPublisher eventPublisher - if (beanDefinitionRegistry instanceof ConfigurableApplicationContext) { - eventPublisher = new ConfigurableApplicationContextEventPublisher((ConfigurableApplicationContext) beanDefinitionRegistry) - } - else if (resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext) { - eventPublisher = new ConfigurableApplicationContextEventPublisher((ConfigurableApplicationContext) resourcePatternResolver.resourceLoader) + // The publisher is registered as a definition rather than constructed here so that the + // datastore holds a reference the container can build, which is what lets the context + // be processed ahead of time. Outside an application context there is nothing to + // publish through, so the no-op publisher stands in as it did before. + if (beanDefinitionRegistry instanceof ConfigurableApplicationContext + || resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext) { + grailsDatastoreEventPublisher(ConfigurableApplicationContextEventPublisher) } else { - eventPublisher = new DefaultApplicationEventPublisher() + grailsDatastoreEventPublisher(DefaultApplicationEventPublisher) } if (mongo == null) { mongoConnectionSourceFactory(MongoConnectionSourceFactory) { bean -> bean.autowire = true } - mongoDatastore(MongoDatastore, configuration, ref('mongoConnectionSourceFactory'), eventPublisher, collectMappedClasses(DATASTORE_TYPE)) + mongoDatastore(MongoDatastore, configuration, ref('mongoConnectionSourceFactory'), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) mongo(mongoDatastore: 'getMongoClient') } else { - mongoDatastore(MongoDatastore, mongo, configuration, eventPublisher, collectMappedClasses(DATASTORE_TYPE)) + mongoDatastore(MongoDatastore, mongo, configuration, ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) } mongoMappingContext(mongoDatastore: 'getMappingContext') diff --git a/grails-data-mongodb/core/src/test/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializerBeanDefinitionsSpec.groovy b/grails-data-mongodb/core/src/test/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializerBeanDefinitionsSpec.groovy new file mode 100644 index 00000000000..25d749146f6 --- /dev/null +++ b/grails-data-mongodb/core/src/test/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializerBeanDefinitionsSpec.groovy @@ -0,0 +1,85 @@ +/* + * 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 grails.mongodb.bootstrap + +import grails.persistence.Entity +import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher +import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher +import org.springframework.beans.factory.config.RuntimeBeanReference +import org.springframework.beans.factory.support.SimpleBeanDefinitionRegistry +import org.springframework.context.support.GenericApplicationContext +import spock.lang.Specification + +/** + * Covers how the datastore receives its event publisher. The definitions are inspected without + * refreshing the context, so no MongoDB is involved. + */ +class MongoDbDataStoreSpringInitializerBeanDefinitionsSpec extends Specification { + + private static final String PUBLISHER = 'grailsDatastoreEventPublisher' + + void 'inside an application context the publisher is registered as a definition'() { + given: + def registry = new GenericApplicationContext() + + when: + new MongoDbDataStoreSpringInitializer(Person).configureForBeanDefinitionRegistry(registry) + + then: 'a definition rather than an already-constructed object, so it can be processed ahead of time' + registry.containsBeanDefinition(PUBLISHER) + registry.getBeanDefinition(PUBLISHER).beanClassName == + ConfigurableApplicationContextEventPublisher.name + + cleanup: + registry.close() + } + + void 'the datastore refers to the publisher by name rather than holding an instance'() { + given: + def registry = new GenericApplicationContext() + + when: + new MongoDbDataStoreSpringInitializer(Person).configureForBeanDefinitionRegistry(registry) + def args = registry.getBeanDefinition('mongoDatastore').constructorArgumentValues + + then: + args.genericArgumentValues*.value + .findAll { it instanceof RuntimeBeanReference } + .any { RuntimeBeanReference reference -> reference.beanName == PUBLISHER } + + cleanup: + registry.close() + } + + void 'outside an application context the no-op publisher is used instead'() { + given: 'a registry that is not a context, as when GORM is bootstrapped standalone' + def registry = new SimpleBeanDefinitionRegistry() + + when: + new MongoDbDataStoreSpringInitializer(Person).configureForBeanDefinitionRegistry(registry) + + then: 'the context-aware publisher would never be given a context here, and would fail on publish' + registry.getBeanDefinition(PUBLISHER).beanClassName == DefaultApplicationEventPublisher.name + } + + @Entity + static class Person { + String name + } +} diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy index 91073cd1c07..bdfbfab1f98 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy @@ -21,6 +21,8 @@ package org.grails.datastore.gorm.events import groovy.transform.CompileStatic +import org.springframework.context.ApplicationContext +import org.springframework.context.ApplicationContextAware import org.springframework.context.ApplicationEvent import org.springframework.context.ApplicationListener import org.springframework.context.ConfigurableApplicationContext @@ -32,14 +34,26 @@ import org.springframework.context.ConfigurableApplicationContext * @since 6.0 */ @CompileStatic -class ConfigurableApplicationContextEventPublisher implements ConfigurableApplicationEventPublisher { +class ConfigurableApplicationContextEventPublisher implements ConfigurableApplicationEventPublisher, ApplicationContextAware { - final ConfigurableApplicationContext applicationContext + ConfigurableApplicationContext applicationContext + + /** + * Takes the context from the container. A bean definition built this way holds no + * already-constructed object, which is what allows it to be processed ahead of time. + */ + ConfigurableApplicationContextEventPublisher() { + } ConfigurableApplicationContextEventPublisher(ConfigurableApplicationContext applicationContext) { this.applicationContext = applicationContext } + @Override + void setApplicationContext(ApplicationContext applicationContext) { + this.applicationContext = (ConfigurableApplicationContext) applicationContext + } + @Override void addApplicationListener(ApplicationListener listener) { this.applicationContext.addApplicationListener(listener) diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy new file mode 100644 index 00000000000..592f3fbe713 --- /dev/null +++ b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy @@ -0,0 +1,80 @@ +/* + * 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.grails.datastore.gorm.events + +import org.springframework.context.ApplicationListener +import org.springframework.context.event.ContextRefreshedEvent +import org.springframework.context.support.GenericApplicationContext +import spock.lang.Specification + +/** + * Covers the publisher being built by the container rather than handed a context, which is what + * lets a datastore reference it as a bean definition instead of an already-constructed object. + */ +class ConfigurableApplicationContextEventPublisherSpec extends Specification { + + GenericApplicationContext context = new GenericApplicationContext() + + void cleanup() { + if (context.active) { + context.close() + } + } + + void 'the container supplies the context to a publisher built without one'() { + given: + context.registerBean('grailsDatastoreEventPublisher', ConfigurableApplicationContextEventPublisher) + + when: + context.refresh() + def publisher = context.getBean('grailsDatastoreEventPublisher', + ConfigurableApplicationContextEventPublisher) + + then: 'nothing passed the context in, so only the container callback can have set it' + publisher.applicationContext.is(context) + } + + void 'a publisher built that way still delivers events and listeners'() { + given: + context.registerBean('grailsDatastoreEventPublisher', ConfigurableApplicationContextEventPublisher) + context.refresh() + def publisher = context.getBean('grailsDatastoreEventPublisher', + ConfigurableApplicationContextEventPublisher) + def received = [] + + when: + publisher.addApplicationListener({ event -> received << event } as ApplicationListener) + def event = new ContextRefreshedEvent(context) + publisher.publishEvent(event) + + then: + received == [event] + } + + void 'the constructor taking a context keeps working'() { + given: 'the form callers outside the container still use' + context.refresh() + + when: + def publisher = new ConfigurableApplicationContextEventPublisher(context) + + then: + publisher.applicationContext.is(context) + } +} From 3206f6055440034066b18cc8d1de0c2b93c0b964 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 5 Aug 2026 21:34:50 -0700 Subject: [PATCH 007/115] Read the Spring Security version without nested reflection The welcome page shows the Spring Security version only when the dependency is present, and reached it with Class.getMethod('getVersion').invoke(null). Calling Method.invoke from a GSP expression goes through Groovy's dynamic dispatch, which resolves to the private caller-sensitive overload the JDK added for core reflection. A native image cannot supply the caller argument that overload requires and aborts the process rather than raising an exception. Spring's ReflectionUtils performs the invocation from Java, so Groovy never dispatches on Method.invoke itself. The presence check is unchanged, which keeps the page compiling for generated applications that did not select Spring Security. Both copies of the page are updated: the one the profiles CLI writes into a new application and the one grails-forge serves. --- .../grails-forge-core/src/main/resources/gsp/index.gsp | 9 +++++++-- grails-profiles/web/skeleton/grails-app/views/index.gsp | 9 +++++++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp b/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp index 97362a9246a..add9c633cc9 100644 --- a/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp +++ b/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp @@ -2,6 +2,7 @@ <%@ page import="org.springframework.boot.SpringBootVersion"%> <%@ page import="org.springframework.core.SpringVersion"%> <%@ page import="org.springframework.util.ClassUtils"%> +<%@ page import="org.springframework.util.ReflectionUtils"%> ${SpringVersion.getVersion()} - <%-- Spring Security: only when the dependency is present --%> + <%-- Spring Security: only when the dependency is present. The call goes + through ReflectionUtils because invoking Method.invoke from Groovy + resolves to a caller-sensitive overload that a native image rejects. --%> + + value="${springSecurityCoreVersionClass ? ReflectionUtils.invokeMethod(ReflectionUtils.findMethod(springSecurityCoreVersionClass, 'getVersion'), null) : null}"/>
  • diff --git a/grails-profiles/web/skeleton/grails-app/views/index.gsp b/grails-profiles/web/skeleton/grails-app/views/index.gsp index 97362a9246a..add9c633cc9 100644 --- a/grails-profiles/web/skeleton/grails-app/views/index.gsp +++ b/grails-profiles/web/skeleton/grails-app/views/index.gsp @@ -2,6 +2,7 @@ <%@ page import="org.springframework.boot.SpringBootVersion"%> <%@ page import="org.springframework.core.SpringVersion"%> <%@ page import="org.springframework.util.ClassUtils"%> +<%@ page import="org.springframework.util.ReflectionUtils"%> ${SpringVersion.getVersion()}
    • - <%-- Spring Security: only when the dependency is present --%> + <%-- Spring Security: only when the dependency is present. The call goes + through ReflectionUtils because invoking Method.invoke from Groovy + resolves to a caller-sensitive overload that a native image rejects. --%> + + value="${springSecurityCoreVersionClass ? ReflectionUtils.invokeMethod(ReflectionUtils.findMethod(springSecurityCoreVersionClass, 'getVersion'), null) : null}"/>
  • From 075c6488722296d8923759a0bfeb41737a37c2a2 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 5 Aug 2026 22:01:10 -0700 Subject: [PATCH 008/115] Add the license header to the AOT example configuration The file was added without one, which fails the release audit. --- .../aot/grails-app/conf/application.yml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/grails-test-examples/aot/grails-app/conf/application.yml b/grails-test-examples/aot/grails-app/conf/application.yml index c6cc7db64ab..4314f81391d 100644 --- a/grails-test-examples/aot/grails-app/conf/application.yml +++ b/grails-test-examples/aot/grails-app/conf/application.yml @@ -1,3 +1,18 @@ +# 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. + grails: profile: web info: From df347f19fa455d072192a76cc3e968c9c1a5ee1d Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 5 Aug 2026 23:43:17 -0700 Subject: [PATCH 009/115] Expand scaffolded views at build time A scaffolded controller had no views of its own: the resolver expanded a template into GSP source and compiled the result the first time each view was asked for. That costs the first request, and a native image cannot do it at all, because defining a class at run time is what an ahead-of-time image gives up. The templates are now expanded during the build and compiled with the rest of the views, so at run time they are found rather than produced. Only naming is substituted, and the templates defer everything about the domain class to the field tag libraries at render time, so this needs no GORM, no application context and no loading of application classes: the controllers are read with ASM and the domain class name is enough. The generated pages are staged with the application's own before a single compilation. Compiling them separately would produce a second gsp/views.properties, and the archive tasks discard duplicates, so one of the two manifests would be lost and the views it listed would never be found. A view the application declares is not generated over, which keeps a hand-written page ahead of a scaffolded one as it is at run time. --- .../GenerateScaffoldedViewsTask.groovy | 245 ++++++++++++++++++ .../plugin/views/gsp/GroovyPagePlugin.groovy | 38 ++- .../GenerateScaffoldedViewsTaskSpec.groovy | 205 +++++++++++++++ 3 files changed, 487 insertions(+), 1 deletion(-) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy new file mode 100644 index 00000000000..3b2e56f7af1 --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy @@ -0,0 +1,245 @@ +/* + * 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.grails.gradle.plugin.scaffolding + +import java.util.jar.JarEntry +import java.util.jar.JarFile + +import groovy.text.GStringTemplateEngine +import groovy.transform.CompileStatic +import groovyjarjarasm.asm.AnnotationVisitor +import groovyjarjarasm.asm.ClassReader +import groovyjarjarasm.asm.ClassVisitor +import groovyjarjarasm.asm.Opcodes +import groovyjarjarasm.asm.Type + +import org.gradle.api.DefaultTask +import org.gradle.api.file.ConfigurableFileCollection +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.tasks.CacheableTask +import org.gradle.api.tasks.InputFiles +import org.gradle.api.tasks.Optional +import org.gradle.api.tasks.OutputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction + +/** + * Writes the views a scaffolded controller would otherwise generate on its first request. + * + *

    Scaffolding expands a template into GSP source and compiles the result, and until now it did + * both when the view was first asked for. That costs the first request on the JVM, and a native + * image cannot do it at all: defining a class at runtime is exactly what an ahead-of-time image + * gives up. Expanding the templates here instead lets the ordinary GSP compiler precompile the + * result, so at runtime the views are found rather than produced.

    + * + *

    Only naming is substituted -- the templates read {@code className} and {@code propertyName}, + * and defer everything about the domain class to the field tag libraries at render time. That is + * why this needs no GORM, no application context and no loading of application classes: the + * controllers are read with ASM and the domain class name is enough.

    + * + *

    A view the application already declares is never overwritten, which keeps the existing + * precedence: a hand-written {@code grails-app/views} page wins over a scaffolded one.

    + * + * @since 8.0 + */ +@CacheableTask +@CompileStatic +abstract class GenerateScaffoldedViewsTask extends DefaultTask { + + /** Descriptor of the annotation that marks a scaffolded controller. */ + private static final String SCAFFOLD_ANNOTATION = 'Lgrails/plugin/scaffolding/annotation/Scaffold;' + + /** Path within an artifact holding the scaffolding templates. */ + private static final String TEMPLATE_PATH = 'META-INF/templates/scaffolding/' + + /** The views scaffolding knows how to produce. */ + private static final List VIEW_NAMES = ['index', 'create', 'edit', 'show'] + + /** Compiled application classes, searched for scaffolded controllers. */ + @InputFiles + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getClassesDirs() + + /** + * The classpath the scaffolding templates are read from. The application's own + * {@code src/main/templates/scaffolding} takes precedence, matching the runtime lookup. + */ + @InputFiles + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getTemplateClasspath() + + /** Application template overrides, normally {@code src/main/templates/scaffolding}. */ + @InputFiles + @Optional + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getTemplateOverrides() + + /** The application's own views; anything declared here is left alone. */ + @InputFiles + @Optional + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getApplicationViews() + + /** Where the generated views are written. */ + @OutputDirectory + abstract DirectoryProperty getOutputDirectory() + + @TaskAction + void generate() { + File outputDir = outputDirectory.get().asFile + outputDir.deleteDir() + outputDir.mkdirs() + + Map templates = loadTemplates() + if (templates.isEmpty()) { + logger.info('No scaffolding templates on the classpath; nothing to generate') + return + } + + Set declared = applicationViews.files + int written = 0 + for (Map.Entry controller : findScaffoldedControllers()) { + String propertyName = controller.value + String className = capitalize(propertyName) + for (String viewName : VIEW_NAMES) { + String template = templates.get(viewName) + if (template == null) { + continue + } + // a view the application wrote itself already wins at runtime, so leaving it out + // keeps build-time and runtime resolution agreeing + if (declared.any { it.path.endsWith("views/${controller.key}/${viewName}.gsp".toString()) }) { + logger.info("Skipping ${controller.key}/${viewName}.gsp, the application declares it") + continue + } + File target = new File(outputDir, "${controller.key}/${viewName}.gsp") + target.parentFile.mkdirs() + target.text = expand(template, className, propertyName) + written++ + } + } + logger.info("Generated ${written} scaffolded view(s)") + } + + /** Expands a template the same way the runtime resolver does, with only the naming bound. */ + private String expand(String template, String className, String propertyName) { + StringWriter out = new StringWriter() + new GStringTemplateEngine() + .createTemplate(template) + .make([className: className, propertyName: propertyName]) + .writeTo(out) + out.toString() + } + + /** + * Maps view name to template text, with the application's overrides winning over the templates + * a plugin contributes. + */ + private Map loadTemplates() { + Map templates = [:] + for (File entry : templateClasspath.files) { + if (entry.isDirectory()) { + File dir = new File(entry, TEMPLATE_PATH) + if (dir.isDirectory()) { + dir.eachFileMatch(~/.*\.gsp/) { File f -> templates.putIfAbsent(baseName(f.name), f.text) } + } + } + else if (entry.name.endsWith('.jar') && entry.isFile()) { + new JarFile(entry).withCloseable { JarFile jar -> + for (JarEntry e : jar.entries()) { + if (e.name.startsWith(TEMPLATE_PATH) && e.name.endsWith('.gsp')) { + templates.putIfAbsent(baseName(e.name.substring(TEMPLATE_PATH.length())), + jar.getInputStream(e).getText('UTF-8')) + } + } + } + } + } + for (File override : templateOverrides.files) { + if (override.isFile() && override.name.endsWith('.gsp')) { + templates.put(baseName(override.name), override.text) + } + } + templates + } + + /** Maps view directory name to the domain property name, for every {@code @Scaffold} controller. */ + private Map findScaffoldedControllers() { + Map found = [:] + for (File dir : classesDirs.files) { + if (!dir.isDirectory()) { + continue + } + dir.eachFileRecurse { File f -> + if (!f.name.endsWith('Controller.class')) { + return + } + String domain = readScaffoldDomain(f) + if (domain != null) { + String controllerName = decapitalize(f.name - 'Controller.class') + found.put(controllerName, decapitalize(domain)) + } + } + } + found + } + + /** + * Returns the simple name of the domain class a controller scaffolds, or {@code null} when it is + * not scaffolded. Read with ASM so the application's classes are never loaded, which keeps the + * task independent of the runtime classpath. + */ + private String readScaffoldDomain(File classFile) { + String domain = null + classFile.withInputStream { InputStream input -> + new ClassReader(input).accept(new ClassVisitor(Opcodes.ASM9) { + @Override + AnnotationVisitor visitAnnotation(String descriptor, boolean visible) { + if (descriptor != SCAFFOLD_ANNOTATION) { + return null + } + return new AnnotationVisitor(Opcodes.ASM9) { + @Override + void visit(String name, Object value) { + // both @Scaffold(User) and @Scaffold(domain = User) name the domain class + if (value instanceof Type && (name == 'value' || name == 'domain')) { + String candidate = ((Type) value).className.tokenize('.').last() + if (candidate != 'Void') { + domain = candidate + } + } + } + } + } + }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES) + } + domain + } + + private static String baseName(String fileName) { + fileName.endsWith('.gsp') ? fileName[0.. { ].findAll { it } ) + // Scaffolded views are expanded from their templates here and staged alongside the + // application's own, so a single compile produces a single gsp/views.properties. Compiling + // them separately would produce a second manifest, and the jar's duplicate handling would + // silently keep only one of them. + Provider stagedViews = project.layout.buildDirectory.dir('generated/views') + def generateScaffoldedViews = tasks.register( + 'generateScaffoldedViews', GenerateScaffoldedViewsTask) { GenerateScaffoldedViewsTask it -> + it.group = BasePlugin.BUILD_GROUP + it.description = 'Expands the views of scaffolded controllers so they can be precompiled' + it.classesDirs.from(classesDirs) + it.templateClasspath.from(project.configurations.named('compileClasspath')) + it.templateOverrides.from( + project.fileTree(project.layout.projectDirectory.dir('src/main/templates/scaffolding')) + .matching { PatternFilterable p -> p.include('*.gsp') }) + it.applicationViews.from( + project.fileTree(project.layout.projectDirectory.dir('grails-app/views')) + .matching { PatternFilterable p -> p.include('**/*.gsp') }) + it.outputDirectory.set(project.layout.buildDirectory.dir('generated/scaffolded-views')) + } + + def stageGroovyPages = tasks.register('stageGroovyPages', Sync) { Sync it -> + it.description = 'Collects the application and scaffolded views for GSP compilation' + it.into(stagedViews) + it.from(project.layout.projectDirectory.dir('grails-app/views')) + it.from(generateScaffoldedViews) + // the application's own page wins, matching how the view resolvers are ordered + it.duplicatesStrategy = DuplicatesStrategy.EXCLUDE + } + def compileGroovyPages = tasks.register('compileGroovyPages', GroovyPageForkCompileTask) { it.destinationDirectory.set(destDir) it.tmpDirPath = getTmpDirPath(project) - it.source = project.layout.projectDirectory.dir('grails-app/views') + // resolved here because the setter takes a directory, not a provider: it has to set + // both srcDir and the SourceTask inputs, and setting srcDir alone compiles nothing + it.source = stagedViews.get() it.serverpath.set('/WEB-INF/grails-app/views/') it.classpath = allClasspath + it.dependsOn(stageGroovyPages) } def compileWebappGroovyPages = tasks.register('compileWebappGroovyPages', GroovyPageForkCompileTask) { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy new file mode 100644 index 00000000000..33ffe0736c5 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy @@ -0,0 +1,205 @@ +/* + * 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.grails.gradle.plugin.scaffolding + +import java.util.jar.JarEntry +import java.util.jar.JarOutputStream + +import groovyjarjarasm.asm.AnnotationVisitor +import groovyjarjarasm.asm.ClassWriter +import groovyjarjarasm.asm.Opcodes +import groovyjarjarasm.asm.Type +import spock.lang.Specification +import spock.lang.TempDir + +import org.gradle.api.Project +import org.gradle.testfixtures.ProjectBuilder + +class GenerateScaffoldedViewsTaskSpec extends Specification { + + @TempDir + File projectDir + + private File classesDir + private File templateJar + + void setup() { + classesDir = new File(projectDir, 'classes') + classesDir.mkdirs() + templateJar = new File(projectDir, 'templates.jar') + writeTemplateJar(templateJar, [ + index : 'list of ${propertyName} for ${className}', + create: 'create ${className}', + edit : 'edit ${className}', + show : 'show ${className}']) + } + + /** A jar shaped like the one the scaffolding plugin publishes. */ + private void writeTemplateJar(File jar, Map templates) { + new JarOutputStream(jar.newOutputStream()).withCloseable { JarOutputStream out -> + templates.each { String name, String body -> + out.putNextEntry(new JarEntry("META-INF/templates/scaffolding/${name}.gsp")) + out.write(body.bytes) + out.closeEntry() + } + } + } + + /** + * Writes a class carrying {@code @Scaffold}, so the task reads a real annotation rather than a + * stand-in for one. + */ + private void writeController(String controllerName, String domainClassName) { + ClassWriter writer = new ClassWriter(0) + writer.visit(Opcodes.V21, Opcodes.ACC_PUBLIC, "com/example/${controllerName}", null, + 'java/lang/Object', null) + AnnotationVisitor annotation = writer.visitAnnotation( + 'Lgrails/plugin/scaffolding/annotation/Scaffold;', true) + annotation.visit('value', Type.getObjectType("com/example/${domainClassName}")) + annotation.visitEnd() + writer.visitEnd() + File target = new File(classesDir, "com/example/${controllerName}.class") + target.parentFile.mkdirs() + target.bytes = writer.toByteArray() + } + + private void writePlainController(String controllerName) { + ClassWriter writer = new ClassWriter(0) + writer.visit(Opcodes.V21, Opcodes.ACC_PUBLIC, "com/example/${controllerName}", null, + 'java/lang/Object', null) + writer.visitEnd() + File target = new File(classesDir, "com/example/${controllerName}.class") + target.parentFile.mkdirs() + target.bytes = writer.toByteArray() + } + + private GenerateScaffoldedViewsTask task(List overrides = [], List views = []) { + Project project = ProjectBuilder.builder().withProjectDir(projectDir).build() + project.tasks.register('generateScaffoldedViews', GenerateScaffoldedViewsTask) { + GenerateScaffoldedViewsTask it -> + it.classesDirs.from(classesDir) + it.templateClasspath.from(templateJar) + it.templateOverrides.from(overrides) + it.applicationViews.from(views) + it.outputDirectory.set(new File(projectDir, 'out')) + } + project.tasks.named('generateScaffoldedViews', GenerateScaffoldedViewsTask).get() + } + + private File generated(GenerateScaffoldedViewsTask task, String path) { + new File(task.outputDirectory.get().asFile, path) + } + + void 'a scaffolded controller gets the full set of views'() { + given: + writeController('UserController', 'User') + def task = task() + + when: + task.generate() + + then: + ['index', 'create', 'edit', 'show'].every { generated(task, "user/${it}.gsp").exists() } + } + + void 'the naming the templates read is substituted'() { + given: + writeController('UserController', 'User') + def task = task() + + when: + task.generate() + + then: + generated(task, 'user/index.gsp').text == 'list of user for User' + } + + void 'a controller without the annotation is left alone'() { + given: + writePlainController('PlainController') + def task = task() + + when: + task.generate() + + then: + !generated(task, 'plain').exists() + } + + void 'the domain class named by the annotation drives the naming, not the controller'() { + given: 'a controller whose name does not match the domain it scaffolds' + writeController('AccountController', 'Person') + def task = task() + + when: + task.generate() + + then: + generated(task, 'account/index.gsp').text == 'list of person for Person' + } + + void 'an application template overrides the one a plugin contributes'() { + given: + writeController('UserController', 'User') + File overrides = new File(projectDir, 'templates') + overrides.mkdirs() + File custom = new File(overrides, 'index.gsp') + custom.text = 'custom ${className}' + def task = task([custom]) + + when: + task.generate() + + then: + generated(task, 'user/index.gsp').text == 'custom User' + } + + void 'a view the application declares is not generated over'() { + given: 'the application writes its own index page' + writeController('UserController', 'User') + File views = new File(projectDir, 'grails-app/views/user') + views.mkdirs() + File declared = new File(views, 'index.gsp') + declared.text = 'hand written' + def task = task([], [declared]) + + when: + task.generate() + + then: 'the runtime prefers the declared page, so generating one would only shadow it' + !generated(task, 'user/index.gsp').exists() + + and: 'the views it does not declare are still generated' + generated(task, 'user/create.gsp').exists() + } + + void 'a stale view from a previous run does not survive'() { + given: + writeController('UserController', 'User') + def task = task() + task.generate() + File stale = generated(task, 'gone/index.gsp') + stale.parentFile.mkdirs() + stale.text = 'stale' + + when: + task.generate() + + then: + !stale.exists() + } +} From 55b7dcc425649b4a0d45b4fbb1a9e007d9c5535f Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 00:06:59 -0700 Subject: [PATCH 010/115] Register the request path's reflective API for ahead-of-time images Handling a request reaches the controller, URL mapping, data binding and content negotiation APIs through Groovy's dynamic dispatch, which reads a type's declared methods to choose an overload. An ahead-of-time image keeps only the members something asks for, so these were stripped and dispatch failed at the point of use. Leaving this to the tracing agent does not work, because the agent records only the paths that were exercised. Each of these failed on a path an ordinary check misses: content negotiation runs only for a request that states what it accepts, the method check only for POST, PUT and DELETE, binding only for a request carrying data, and the parameter accessor only once a mapping carries parameters. All four passed a page walk and failed for a real visitor. Each registrar sits in the module owning the API and names its types as strings, registering only those present, so an application that does not use a given plugin is unaffected. None of this varies between applications, which is why it belongs with the framework rather than in every application's metadata. --- .../aot/ControllerRuntimeHints.java | 68 +++++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + .../aot/ControllerRuntimeHintsSpec.groovy | 73 +++++++++++++++++++ .../web/mime/aot/MimeTypeRuntimeHints.java | 56 ++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + .../aot/DataBindingRuntimeHints.java | 61 ++++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + .../mapping/aot/UrlMappingRuntimeHints.java | 60 +++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + 9 files changed, 326 insertions(+) create mode 100644 grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java create mode 100644 grails-controllers/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy create mode 100644 grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java create mode 100644 grails-mimetypes/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java create mode 100644 grails-web-databinding/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java create mode 100644 grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories diff --git a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java b/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java new file mode 100644 index 00000000000..e37c7730d98 --- /dev/null +++ b/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java @@ -0,0 +1,68 @@ +/* + * 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.grails.plugins.web.controllers.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * Registers the controller API a request is dispatched through. + * + *

    A controller action reaches these through Groovy's dynamic dispatch, which reads a type's + * declared methods to choose an overload. An ahead-of-time image keeps only the members something + * asks for, so without these hints the methods are absent and dispatch fails at the point of use -- + * on the request that first takes that path, rather than at start-up.

    + * + *

    Recording this here rather than leaving it to a tracing agent matters because the agent only + * ever sees the paths a developer happened to exercise: the method check below is reached only by + * POST, PUT and DELETE, so a walk of an application's pages never records it and the failure + * appears the first time someone submits a form.

    + * + * @since 8.0 + */ +public class ControllerRuntimeHints implements RuntimeHintsRegistrar { + + /** + * Types Groovy dispatches on while handling a request. Named as strings, and registered only + * when present, so this stays correct for an application that does not use every plugin. + */ + private static final String[] DISPATCHED_TYPES = { + "grails.artefact.Controller", + "grails.artefact.controller.support.AllowedMethodsHelper", + "grails.artefact.controller.support.RequestForwarder", + "grails.artefact.controller.support.ResponseRedirector", + "grails.artefact.controller.support.ResponseRenderer", + "grails.artefact.controller.RestResponder", + // a view asking who is logged in reaches the request's principal, and Groovy makes that + // call on the interface rather than the implementation the container supplies + "java.security.Principal" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String type : DISPATCHED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + } + } +} diff --git a/grails-controllers/src/main/resources/META-INF/spring/aot.factories b/grails-controllers/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..a8cb0eb8035 --- /dev/null +++ b/grails-controllers/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.plugins.web.controllers.aot.ControllerRuntimeHints diff --git a/grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy b/grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..8467a537142 --- /dev/null +++ b/grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy @@ -0,0 +1,73 @@ +/* + * 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.grails.plugins.web.controllers.aot + +import grails.artefact.controller.support.AllowedMethodsHelper + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +/** + * Covers the controller API surviving into an ahead-of-time image. Without these hints the methods + * are stripped and dispatch fails on the request that first takes the path, which for the method + * check below means the first form submission rather than start-up. + */ +class ControllerRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new ControllerRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private boolean registered(Class type) { + def hint = hints.reflection().getTypeHint(TypeReference.of(type)) + hint != null && hint.memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the method check a form submission reaches is registered'() { + expect: 'reached only by POST, PUT and DELETE, so a walk of an application never records it' + registered(AllowedMethodsHelper) + } + + void 'the controller trait Groovy dispatches through is registered'() { + expect: + registered(grails.artefact.Controller) + } + + void 'the response and forwarding support types are registered'() { + expect: + registered(grails.artefact.controller.support.ResponseRenderer) + registered(grails.artefact.controller.support.ResponseRedirector) + registered(grails.artefact.controller.support.RequestForwarder) + } + + void 'a type absent from the classpath is skipped rather than failing the build'() { + given: + RuntimeHints empty = new RuntimeHints() + + when: 'no class loader can resolve the named types' + new ControllerRuntimeHints().registerHints(empty, new URLClassLoader(new URL[0], null)) + + then: + noExceptionThrown() + } +} diff --git a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java b/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java new file mode 100644 index 00000000000..de6c2005a50 --- /dev/null +++ b/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java @@ -0,0 +1,56 @@ +/* + * 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.grails.web.mime.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * Registers the content negotiation API. + * + *

    Negotiation runs only for a request that states what it accepts. A browser always does; + * a bare command-line request does not, which is why the absence of these hints can pass an + * automated check and still fail for every real visitor.

    + * + * @since 8.0 + */ +public class MimeTypeRuntimeHints implements RuntimeHintsRegistrar { + + /** + * Types Groovy dispatches on. Named as strings, and registered only when present, so this stays + * correct for an application that does not use every plugin. + */ + private static final String[] DISPATCHED_TYPES = { + "grails.web.mime.MimeType", + "org.grails.web.mime.DefaultAcceptHeaderParser", + "org.grails.web.mime.DefaultMimeUtility" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String type : DISPATCHED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + } + } +} diff --git a/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories b/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..e6d118d9714 --- /dev/null +++ b/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.web.mime.aot.MimeTypeRuntimeHints diff --git a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java b/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java new file mode 100644 index 00000000000..4c617da1598 --- /dev/null +++ b/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java @@ -0,0 +1,61 @@ +/* + * 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.grails.web.databinding.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * Registers the data binding API a request is bound through. + * + *

    Binding is reached only by a request that carries a body or parameters to bind, so a + * read-only walk of an application never records it and the absence shows up the first time + * a form is submitted.

    + * + * @since 8.0 + */ +public class DataBindingRuntimeHints implements RuntimeHintsRegistrar { + + /** + * Types Groovy dispatches on. Named as strings, and registered only when present, so this stays + * correct for an application that does not use every plugin. + */ + private static final String[] DISPATCHED_TYPES = { + "grails.web.databinding.WebDataBinding", + "grails.web.databinding.DataBindingUtils", + "grails.databinding.DataBindingSource", + "grails.databinding.BindingHelper", + "grails.databinding.converters.ValueConverter", + // binding asks a target type whether it is an array, and Groovy makes that call + // reflectively on the Class object rather than directly + "java.lang.Class" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String type : DISPATCHED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + } + } +} diff --git a/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories b/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..09045e2d0db --- /dev/null +++ b/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.web.databinding.aot.DataBindingRuntimeHints diff --git a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java b/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java new file mode 100644 index 00000000000..b716a43f78a --- /dev/null +++ b/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java @@ -0,0 +1,60 @@ +/* + * 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.grails.web.mapping.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * Registers the URL mapping API a request is dispatched through. + * + *

    Resolving a request reads the matched mapping reflectively through Groovy, so the + * declared methods of these types have to survive into the image. The parameter accessor in + * particular is reached only once a mapping carries parameters, which a walk of an + * application's pages need not do.

    + * + * @since 8.0 + */ +public class UrlMappingRuntimeHints implements RuntimeHintsRegistrar { + + /** + * Types Groovy dispatches on. Named as strings, and registered only when present, so this stays + * correct for an application that does not use every plugin. + */ + private static final String[] DISPATCHED_TYPES = { + "grails.web.mapping.UrlMappingInfo", + "grails.web.mapping.UrlMapping", + "grails.web.mapping.UrlMappings", + "grails.web.mapping.UrlCreator", + "grails.web.mapping.LinkGenerator", + "grails.web.mapping.UrlMappingData" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String type : DISPATCHED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + } + } +} diff --git a/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories b/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..f1d12f9db9c --- /dev/null +++ b/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.web.mapping.aot.UrlMappingRuntimeHints From 3b3537d1546d304da0fbe01e0b318c8fdfd0f053 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 00:23:35 -0700 Subject: [PATCH 011/115] Register the framework's closures for ahead-of-time images Calling a closure goes through doCall, and Groovy reads its parameter types reflectively to choose an overload. In an ahead-of-time image those are stripped unless something asks for them, and the call then fails where the closure is used rather than at start-up. The framework ships thousands across its plugins, so naming them would be neither complete nor stable, and leaving it to each application means every one of them rediscovers the same list. They are found while the hints are written instead. That happens during the build, on an ordinary JVM with the whole classpath, so scanning is available; it is only the image that cannot do it. Two kinds of closure are deliberately left out, both of which otherwise fail the build rather than degrading at run time. One is a closure whose declaring class does not resolve: the GSP compiler's task extends an Ant type absent at run time, and its closures reach it through invokedynamic, so nothing in their own bytecode reveals the dependency. The other is a closure naming an absent class in a method body: the JSP closures link happily against a runtime with no JSP API, because loading a class resolves its signatures and not the bodies the image analysis goes on to parse. --- .../beans/aot/GrailsClosureRuntimeHints.java | 204 ++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 3 + .../aot/GrailsClosureRuntimeHintsSpec.groovy | 74 +++++++ 3 files changed, 281 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java new file mode 100644 index 00000000000..353cdba4f45 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -0,0 +1,204 @@ +/* + * 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.grails.spring.beans.aot; + +import java.io.IOException; +import java.io.InputStream; +import java.util.LinkedHashSet; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.springframework.asm.ClassReader; +import org.springframework.asm.SpringAsmInfo; +import org.springframework.asm.ClassVisitor; +import org.springframework.asm.MethodVisitor; +import org.springframework.asm.Type; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.core.io.Resource; +import org.springframework.core.io.support.PathMatchingResourcePatternResolver; +import org.springframework.core.io.support.ResourcePatternResolver; +import org.springframework.core.type.classreading.CachingMetadataReaderFactory; +import org.springframework.core.type.classreading.MetadataReaderFactory; +import org.springframework.lang.Nullable; +import org.springframework.util.ClassUtils; + +/** + * Registers the framework closures Groovy dispatches through. + * + *

    Calling a closure goes through {@code doCall}, and Groovy reads its parameter types + * reflectively to choose an overload. In an ahead-of-time image those types are stripped unless + * something asks for them, and the call fails where the closure is used rather than at start-up. + * The framework ships thousands of closures across its plugins, so naming them individually would + * be neither complete nor stable.

    + * + *

    They are found here instead, while the hints are being written. That happens during the build, + * on an ordinary JVM with the full classpath, so scanning is available -- it is only the image that + * cannot do it. A closure whose own bytecode does not resolve is skipped: the GSP compiler's Ant + * task is on the compile classpath but Ant is not on the runtime one, and registering it would make + * the image analysis parse a class whose supertype is absent, failing the build.

    + * + * @since 8.0 + */ +public class GrailsClosureRuntimeHints implements RuntimeHintsRegistrar { + + private static final Log logger = LogFactory.getLog(GrailsClosureRuntimeHints.class); + + /** Closures live under the framework's own packages; an application's are registered elsewhere. */ + private static final String[] PATTERNS = { + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "grails/**/*_closure*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/**/*_closure*.class" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); + ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); + MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver); + int registered = 0; + for (String pattern : PATTERNS) { + Resource[] resources; + try { + resources = resolver.getResources(pattern); + } + catch (IOException ex) { + logger.warn("Unable to scan for Grails closures matching " + pattern, ex); + continue; + } + for (Resource resource : resources) { + String className = classNameOf(metadataReaderFactory, resource); + if (className != null && resolves(className, resource, loader)) { + hints.reflection().registerTypeIfPresent(loader, className, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + registered++; + } + } + } + logger.debug("Registered " + registered + " Grails closures for reflection"); + } + + @Nullable + private String classNameOf(MetadataReaderFactory factory, Resource resource) { + try { + return factory.getMetadataReader(resource).getClassMetadata().getClassName(); + } + catch (IOException | RuntimeException ex) { + return null; + } + } + + /** + * Whether every class the closure names resolves on this classpath. + * + *

    Loading the class is not enough: that resolves its declaration and the types in its method + * signatures, but not the ones its bodies reference, and the image analysis parses those bodies. + * The GSP compiler's JSP closures link happily against a runtime with no JSP API and then fail + * the build, so the references are read directly instead.

    + */ + private boolean resolves(String className, Resource resource, ClassLoader loader) { + // A closure cannot be reached unless the class declaring it can be: the GSP compiler's task + // extends an Ant type that is absent at run time, and its closures reach it through + // invokedynamic, so the reference is not visible in the bytecode read below. + int declaring = className.indexOf("$_"); + if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), loader)) { + logger.trace("Skipping closure whose declaring class does not resolve: " + className); + return false; + } + Set referenced = new LinkedHashSet<>(); + try (InputStream input = resource.getInputStream()) { + new ClassReader(input).accept(new ReferenceCollector(referenced), + ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); + } + catch (IOException | RuntimeException ex) { + return false; + } + for (String name : referenced) { + if (!ClassUtils.isPresent(name, loader)) { + logger.trace("Skipping closure referencing " + name + ", absent from this classpath"); + return false; + } + } + return true; + } + + /** Collects the types a class names, in its own declaration and in the bodies of its methods. */ + private static final class ReferenceCollector extends ClassVisitor { + + private final Set referenced; + + private ReferenceCollector(Set referenced) { + super(SpringAsmInfo.ASM_VERSION); + this.referenced = referenced; + } + + private void add(@Nullable String internalName) { + if (internalName == null || internalName.startsWith("[")) { + return; + } + String className = ClassUtils.convertResourcePathToClassName(internalName); + // the JDK is always present, and skipping it keeps this to the classes that can be absent + if (!className.startsWith("java.") && !className.startsWith("jdk.")) { + referenced.add(className); + } + } + + @Override + public void visit(int version, int access, String name, String signature, String superName, + String[] interfaces) { + add(superName); + if (interfaces != null) { + for (String each : interfaces) { + add(each); + } + } + } + + @Override + public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, + String[] exceptions) { + for (Type argument : Type.getArgumentTypes(descriptor)) { + add(argument.getSort() == Type.OBJECT ? argument.getInternalName() : null); + } + return new MethodVisitor(SpringAsmInfo.ASM_VERSION) { + @Override + public void visitTypeInsn(int opcode, String type) { + add(type); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String methodName, + String methodDescriptor, boolean isInterface) { + add(owner); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String fieldName, + String fieldDescriptor) { + add(owner); + } + }; + } + } + +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index 2b6b9870fe9..3a2f1229ece 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,5 @@ org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter=\ org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter + +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.spring.beans.aot.GrailsClosureRuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..20690e9ad3f --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.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.grails.spring.beans.aot + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +/** + * Covers the framework's closures being found while the hints are written, rather than named one by + * one. Groovy reads {@code doCall}'s parameter types to choose an overload, so a closure missing + * from an image fails where it is used rather than at start-up. + */ +class GrailsClosureRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + private List registeredTypes() { + hints.reflection().typeHints().collect { it.type.name } + } + + void 'the framework closures on the classpath are registered'() { + when: + new GrailsClosureRuntimeHints().registerHints(hints, getClass().classLoader) + + then: 'this module alone ships plenty, so a scan that found nothing would be broken' + registeredTypes().count { it.contains('_closure') } > 0 + } + + void 'a registered closure can have its parameter types read'() { + given: + new GrailsClosureRuntimeHints().registerHints(hints, getClass().classLoader) + + when: + def closure = registeredTypes().find { it.contains('_closure') } + def hint = hints.reflection().getTypeHint(TypeReference.of(closure)) + + then: 'that is the access Groovy needs to select an overload' + hint.memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'only framework closures are registered'() { + when: + new GrailsClosureRuntimeHints().registerHints(hints, getClass().classLoader) + + then: 'an application registers its own; this must not reach outside the framework' + registeredTypes().every { it.startsWith('grails.') || it.startsWith('org.grails.') } + } + + void 'a class loader that resolves nothing yields no hints rather than failing'() { + when: + new GrailsClosureRuntimeHints().registerHints(hints, new URLClassLoader(new URL[0], null)) + + then: + noExceptionThrown() + } +} From 842ce6f07b0f2610c4a1b6659c5442240fd8d95a Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 00:59:09 -0700 Subject: [PATCH 012/115] Record an application's own classes and pages for ahead-of-time images Grails reaches an application's artefacts reflectively, and a precompiled page is looked up by the name recorded for its view, so a native image that keeps only the members something asked for leaves both present but unusable. Until now an application had to run under the tracing agent to discover them, which records only the paths that were exercised: a page nobody visited during the trace is a page missing from the image. The build already knows the answer. The compiled classes are on disk and the pages are named in the manifest the GSP compiler writes, so both are read directly. Pages a plugin contributes are read from the manifest inside its artifact as well, because an application renders those as readily as its own and they are not in its own build output. The closure registration is widened at the same time. A plugin declares its descriptor in whatever package it chooses, and the bean definitions in that descriptor are closures the container calls while the context is built, so scanning only the framework's own packages missed them. --- .../beans/aot/GrailsClosureRuntimeHints.java | 10 +- .../aot/GrailsClosureRuntimeHintsSpec.groovy | 8 +- .../aot/GenerateNativeMetadataTask.groovy | 188 ++++++++++++++++++ .../plugin/core/GrailsGradlePlugin.groovy | 26 +++ 4 files changed, 227 insertions(+), 5 deletions(-) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java index 353cdba4f45..35f5b9e5bed 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -64,10 +64,16 @@ public class GrailsClosureRuntimeHints implements RuntimeHintsRegistrar { private static final Log logger = LogFactory.getLog(GrailsClosureRuntimeHints.class); - /** Closures live under the framework's own packages; an application's are registered elsewhere. */ + /** + * Where the framework's closures are found. The first two cover its own packages; the third + * covers plugin descriptors, which a plugin may declare in any package of its choosing -- the + * asset pipeline names its own {@code asset.pipeline}, and its bean definitions are closures + * the container calls while the context is built. + */ private static final String[] PATTERNS = { ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "grails/**/*_closure*.class", - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/**/*_closure*.class" + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/**/*_closure*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "**/*GrailsPlugin$*_closure*.class" }; @Override diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy index 20690e9ad3f..f33f20cad4a 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy @@ -56,12 +56,14 @@ class GrailsClosureRuntimeHintsSpec extends Specification { hint.memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) } - void 'only framework closures are registered'() { + void 'only framework and plugin descriptor closures are registered'() { when: new GrailsClosureRuntimeHints().registerHints(hints, getClass().classLoader) - then: 'an application registers its own; this must not reach outside the framework' - registeredTypes().every { it.startsWith('grails.') || it.startsWith('org.grails.') } + then: 'a plugin may sit in any package, but nothing else should be swept up' + registeredTypes().every { + it.startsWith('grails.') || it.startsWith('org.grails.') || it.contains('GrailsPlugin$') + } } void 'a class loader that resolves nothing yields no hints rather than failing'() { diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy new file mode 100644 index 00000000000..9174be9b393 --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy @@ -0,0 +1,188 @@ +/* + * 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.grails.gradle.plugin.aot + +import groovy.json.JsonOutput +import groovy.transform.CompileStatic + +import org.gradle.api.DefaultTask +import org.gradle.api.file.ConfigurableFileCollection +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.tasks.CacheableTask +import org.gradle.api.tasks.InputFiles +import org.gradle.api.tasks.Optional +import org.gradle.api.tasks.OutputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction + +/** + * Records the application's own classes so they survive into a native image. + * + *

    Grails reaches an application's artefacts reflectively -- a controller's actions, a domain + * class's properties, a tag library's methods -- and a precompiled page is looked up by the name + * recorded for its view. A native image keeps only the members something asks for, so without this + * the classes are present but unusable.

    + * + *

    The answer is already in the build output: the compiled classes are on disk and the pages are + * listed in the manifest the GSP compiler writes. Reading them here means an application does not + * have to run under the tracing agent to be buildable, which matters because the agent records only + * the paths that were exercised -- a page never visited during the trace is a page missing from the + * image.

    + * + * @since 8.0 + */ +@CacheableTask +@CompileStatic +abstract class GenerateNativeMetadataTask extends DefaultTask { + + /** Where the generated metadata is written within the artifact. */ + static final String METADATA_PATH = 'META-INF/native-image/grails/reachability-metadata.json' + + /** The manifest the GSP compiler writes, mapping a view to the class it compiled to. */ + static final String VIEWS_MANIFEST = 'gsp/views.properties' + + /** Compiled application classes. */ + @InputFiles + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getClassesDirs() + + /** Compiled pages, including the manifest naming them. */ + @InputFiles + @Optional + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getPageClassesDirs() + + /** + * The classpath whose artifacts may carry their own pages. A plugin ships compiled pages and the + * manifest naming them, and an application renders those as readily as its own. + */ + @InputFiles + @Optional + @PathSensitive(PathSensitivity.RELATIVE) + abstract ConfigurableFileCollection getPageClasspath() + + @OutputDirectory + abstract DirectoryProperty getOutputDirectory() + + @TaskAction + void generate() { + Set types = [] as Set + types.addAll(applicationClasses()) + types.addAll(pageClasses()) + types.addAll(pageClassesFromClasspath()) + + List> reflection = types.sort().collect { String type -> + [ + type : type, + allDeclaredMethods : true, + allDeclaredFields : true, + allDeclaredConstructors : true + ] as Map + } + + File target = new File(outputDirectory.get().asFile, METADATA_PATH) + target.parentFile.mkdirs() + target.text = JsonOutput.prettyPrint(JsonOutput.toJson([reflection: reflection])) + logger.info("Recorded ${reflection.size()} application types for reflection") + } + + /** The pages a plugin contributes, read from the manifest each of its artifacts carries. */ + private Set pageClassesFromClasspath() { + Set found = [] as Set + for (File entry : pageClasspath.files) { + if (!entry.isFile() || !entry.name.endsWith('.jar')) { + continue + } + try { + new java.util.jar.JarFile(entry).withCloseable { java.util.jar.JarFile jar -> + java.util.jar.JarEntry manifest = jar.getJarEntry(VIEWS_MANIFEST) + if (manifest == null) { + return + } + Properties views = new Properties() + jar.getInputStream(manifest).withCloseable { views.load(it) } + for (Object value : views.values()) { + found << value.toString() + } + // the closures a page declares are reached the same way its body is + for (java.util.jar.JarEntry e : jar.entries()) { + String name = e.name + if (name.endsWith('.class') && name.contains('$') && !name.contains('/')) { + String simple = name[0.. applicationClasses() { + Set found = [] as Set + for (File dir : classesDirs.files) { + if (!dir.isDirectory()) { + continue + } + dir.eachFileRecurse { File file -> + if (file.name.endsWith('.class')) { + String relative = dir.toPath().relativize(file.toPath()).toString() + found << relative[0.. pageClasses() { + Set found = [] as Set + for (File dir : pageClassesDirs.files) { + File manifest = new File(dir, VIEWS_MANIFEST) + if (!manifest.isFile()) { + continue + } + Properties views = new Properties() + manifest.withInputStream { views.load(it) } + Set pages = views.values().collect { it.toString() } as Set + found.addAll(pages) + // a page's closures are reached the same way its body is; the directory is walked once + // rather than per page, which matters for an application with many views + dir.eachFileRecurse { File file -> + if (!file.name.endsWith('.class')) { + return + } + String name = file.name[0.. 0 && pages.contains(name.substring(0, nested))) { + found << name + } + } + } + found + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 805deadf427..012c46d75f9 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -65,6 +65,8 @@ import org.grails.gradle.plugin.commands.GrailsCliGradlePlugin import org.grails.gradle.plugin.exploded.ExplodedCompatibilityRule import org.grails.gradle.plugin.exploded.ExplodedDisambiguationRule import org.grails.gradle.plugin.exploded.GrailsExplodedPlugin +import org.gradle.api.plugins.BasePlugin +import org.grails.gradle.plugin.aot.GenerateNativeMetadataTask import org.grails.gradle.plugin.model.GrailsClasspathToolingModelBuilder import org.grails.gradle.plugin.run.FindMainClassTask import org.grails.gradle.plugin.util.SourceSets @@ -132,6 +134,8 @@ class GrailsGradlePlugin implements Plugin { enableNative2Ascii(project, grailsVersion) + configureNativeMetadata(project) + configureTemplateResources(project) configureAssetCompilation(project) @@ -1115,6 +1119,28 @@ ${importStatements} } } + /** + * Records the application's own classes and pages so a native image keeps them usable. The build + * output already names both, so an application does not have to be traced to be buildable. + */ + protected void configureNativeMetadata(Project project) { + SourceSet sourceSet = SourceSets.findMainSourceSet(project) + + TaskProvider metadataTask = project.tasks.register( + 'generateNativeMetadata', GenerateNativeMetadataTask) { GenerateNativeMetadataTask task -> + task.group = BasePlugin.BUILD_GROUP + task.description = 'Records the application classes and pages a native image must keep' + task.classesDirs.from(sourceSet.output.classesDirs) + task.pageClassesDirs.from(project.layout.buildDirectory.dir('gsp-classes/main')) + task.pageClasspath.from(project.configurations.named('runtimeClasspath')) + task.outputDirectory.set(project.layout.buildDirectory.dir('generated-resources/grails-native')) + } + + project.tasks.named(sourceSet.processResourcesTaskName, ProcessResources).configure { ProcessResources task -> + task.from(metadataTask) + } + } + /** * Enables native2ascii processing of resource bundles **/ From fa8e4e4fc1efcb10767217c0a1d1de08fff2bf1e Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 08:39:07 -0700 Subject: [PATCH 013/115] Register the rendering, scaffolding and persistence runtimes A rendered page and a persisted entity are both reached through Groovy, so an image that keeps only the members something asked for serves part of an application and fails on the rest. What fails depends on what was exercised: a page renders until it reaches a tag that was stripped, and a datastore reads until something writes. Three registrars cover the runtimes an application does not own: Tag libraries and the page runtime, found by name wherever a plugin declares them. A flash message only exists after a redirect that set one, and a field is only rendered by a form, so a walk of an application's pages exercises neither and both fail for the first person who edits a record. The scaffolded resource controller, including the protected methods it defines for the write operations, which serving its pages never reaches. The persistence runtime, registered by package so that a datastore's own persisters and query support are covered without the shared module naming any of them. Fields are registered as well as methods: a persister hands work to anonymous inner classes that read the state they captured as properties, which is how removing an entity reaches its session. Each skips a type that does not resolve. The JSP integration and the datastores are compiled against APIs an application need not have, and registering a type the image analysis then cannot parse fails the build rather than degrading at run time. The two build tasks state their dependency on the compilation rather than inferring it from the classes directory, which more than one task writes to. --- .../datastore/gorm/aot/GormRuntimeHints.java | 122 ++++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + .../gorm/aot/GormRuntimeHintsSpec.groovy | 81 +++++++++++ .../plugin/core/GrailsGradlePlugin.groovy | 9 ++ .../plugin/views/gsp/GroovyPagePlugin.groovy | 8 ++ .../web/taglib/aot/TagLibRuntimeHints.java | 130 ++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + .../aot/ScaffoldingRuntimeHints.java | 53 +++++++ .../resources/META-INF/spring/aot.factories | 2 + 9 files changed, 409 insertions(+) create mode 100644 grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java create mode 100644 grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy create mode 100644 grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java create mode 100644 grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java create mode 100644 grails-scaffolding/src/main/resources/META-INF/spring/aot.factories diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java new file mode 100644 index 00000000000..2d76b6038f9 --- /dev/null +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java @@ -0,0 +1,122 @@ +/* + * 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.grails.datastore.gorm.aot; + +import java.io.IOException; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.core.io.Resource; +import org.springframework.core.io.support.PathMatchingResourcePatternResolver; +import org.springframework.core.io.support.ResourcePatternResolver; +import org.springframework.core.type.classreading.CachingMetadataReaderFactory; +import org.springframework.core.type.classreading.MetadataReaderFactory; +import org.springframework.lang.Nullable; +import org.springframework.util.ClassUtils; + +/** + * Registers the persistence runtime a datastore reaches through Groovy. + * + *

    Reading and writing an entity goes through the mapping context, the persister for its + * datastore, and the query and event machinery around them, and Groovy reaches all of it + * dynamically. Fields are registered as well as methods because a persister hands work to anonymous + * inner classes that read the state they captured as properties -- deleting an entity reads the + * session that way -- and a native image that keeps only the members something asked for leaves the + * class present with that state unreachable.

    + * + *

    Which datastore is registered follows from what is on the classpath: the scan covers the shared + * packages, and an implementation puts its own persisters and query support in them, so MongoDB and + * the others are covered without naming any of them here.

    + * + *

    Recording this with the framework rather than leaving it to a tracing agent matters because the + * agent records only what ran. Reads are exercised by anything that opens a page; the write and + * delete paths reach persister internals that a read never touches, so they fail for the first + * person who saves or removes a record.

    + * + * @since 8.0 + */ +public class GormRuntimeHints implements RuntimeHintsRegistrar { + + private static final Log logger = LogFactory.getLog(GormRuntimeHints.class); + + /** + * The persistence runtime. Registered by package: naming the types one at a time describes only + * the operations that have been run so far, and every datastore adds its own. + */ + private static final String[] PATTERNS = { + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/datastore/mapping/**/*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/datastore/gorm/**/*.class" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); + ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); + MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver); + int registered = 0; + for (String pattern : PATTERNS) { + Resource[] resources; + try { + resources = resolver.getResources(pattern); + } + catch (IOException ex) { + logger.warn("Unable to scan for the persistence runtime matching " + pattern, ex); + continue; + } + for (Resource resource : resources) { + String className; + try { + className = metadataReaderFactory.getMetadataReader(resource) + .getClassMetadata().getClassName(); + } + catch (IOException | RuntimeException ex) { + continue; + } + if (!resolves(className, loader)) { + continue; + } + hints.reflection().registerTypeIfPresent(loader, className, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, + MemberCategory.ACCESS_DECLARED_FIELDS, + MemberCategory.ACCESS_PUBLIC_FIELDS); + registered++; + } + } + logger.debug("Registered " + registered + " persistence runtime types for reflection"); + } + + /** + * Whether the type, and the class declaring it, resolve here. A datastore compiles against a + * driver an application need not have, and registering a type the image analysis then cannot + * parse fails the build rather than degrading at run time. + */ + private boolean resolves(String className, ClassLoader loader) { + int declaring = className.indexOf('$'); + if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), loader)) { + return false; + } + return ClassUtils.isPresent(className, loader); + } +} diff --git a/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories b/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..2161ffba18f --- /dev/null +++ b/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.datastore.gorm.aot.GormRuntimeHints diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..3f106982a57 --- /dev/null +++ b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy @@ -0,0 +1,81 @@ +/* + * 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.grails.datastore.gorm.aot + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +/** + * Covers the persistence runtime surviving into an ahead-of-time image. A read exercises little of + * it, so what is missing shows up when a record is written or removed rather than at start-up. + */ +class GormRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new GormRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private Set registeredTypes() { + hints.reflection().typeHints().collect { it.type.name } as Set + } + + private boolean hasCategory(String type, MemberCategory category) { + def hint = hints.reflection().getTypeHint(TypeReference.of(type)) + hint != null && hint.memberCategories.contains(category) + } + + void 'the mapping context a datastore is driven through is registered'() { + expect: + registeredTypes().contains('org.grails.datastore.mapping.model.MappingContext') + } + + void 'fields are registered, not only methods'() { + given: 'a persister hands work to inner classes that read what they captured as properties' + String type = registeredTypes().find { + it.startsWith('org.grails.datastore.mapping.') + } + + expect: + hasCategory(type, MemberCategory.ACCESS_DECLARED_FIELDS) + hasCategory(type, MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the scan reaches the persistence packages and nothing outside them'() { + expect: + registeredTypes().size() > 0 + registeredTypes().every { + it.startsWith('org.grails.datastore.mapping.') || it.startsWith('org.grails.datastore.gorm.') + } + } + + void 'a class loader that resolves nothing yields no hints rather than failing'() { + given: + RuntimeHints empty = new RuntimeHints() + + when: + new GormRuntimeHints().registerHints(empty, new URLClassLoader(new URL[0], null)) + + then: + noExceptionThrown() + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 012c46d75f9..d5223b25c52 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -1130,6 +1130,15 @@ ${importStatements} 'generateNativeMetadata', GenerateNativeMetadataTask) { GenerateNativeMetadataTask task -> task.group = BasePlugin.BUILD_GROUP task.description = 'Records the application classes and pages a native image must keep' + // The classes directory is written by more than one task, so the dependency has to be + // stated. It is stated against the compilation rather than the classes task, because + // the classes task also runs processResources, which consumes this task's output. + task.dependsOn(project.tasks.named(sourceSet.compileJavaTaskName)) + ['compileGroovy', 'copyAstClasses'].each { String name -> + if (project.tasks.findByName(name)) { + task.dependsOn(project.tasks.named(name)) + } + } task.classesDirs.from(sourceSet.output.classesDirs) task.pageClassesDirs.from(project.layout.buildDirectory.dir('gsp-classes/main')) task.pageClasspath.from(project.configurations.named('runtimeClasspath')) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy index c980cc62836..fee4e659457 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy @@ -82,6 +82,14 @@ class GroovyPagePlugin implements Plugin { 'generateScaffoldedViews', GenerateScaffoldedViewsTask) { GenerateScaffoldedViewsTask it -> it.group = BasePlugin.BUILD_GROUP it.description = 'Expands the views of scaffolded controllers so they can be precompiled' + // the classes directory is written by more than one task, so the dependency is stated + // against the compilation rather than inferred from the directory + it.dependsOn(tasks.named('compileJava')) + ['compileGroovy', 'copyAstClasses'].each { String name -> + if (project.tasks.findByName(name)) { + it.dependsOn(tasks.named(name)) + } + } it.classesDirs.from(classesDirs) it.templateClasspath.from(project.configurations.named('compileClasspath')) it.templateOverrides.from( diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java new file mode 100644 index 00000000000..21c61db532a --- /dev/null +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java @@ -0,0 +1,130 @@ +/* + * 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.grails.plugins.web.taglib.aot; + +import java.io.IOException; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.core.io.Resource; +import org.springframework.core.io.support.PathMatchingResourcePatternResolver; +import org.springframework.core.io.support.ResourcePatternResolver; +import org.springframework.core.type.classreading.CachingMetadataReaderFactory; +import org.springframework.core.type.classreading.MetadataReaderFactory; +import org.springframework.lang.Nullable; +import org.springframework.util.ClassUtils; + +/** + * Registers the tag libraries and page runtime a rendered page dispatches through. + * + *

    A tag is resolved by name and invoked reflectively, so an image that keeps only the members + * something asked for renders a page until it reaches a tag it stripped. Which tags those are + * depends on what the page does: a field is only rendered by a form, and a flash message only + * exists after a redirect that set one, so a walk of an application's pages exercises neither and + * they fail for the first person who edits something.

    + * + *

    Tag libraries are found rather than named. A plugin declares its own in whatever package it + * chooses, and its tags are as reachable from a page as the framework's own.

    + * + * @since 8.0 + */ +public class TagLibRuntimeHints implements RuntimeHintsRegistrar { + + private static final Log logger = LogFactory.getLog(TagLibRuntimeHints.class); + + /** A tag library is identified by its name, wherever it is declared. */ + private static final String TAGLIB_PATTERN = + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "**/*TagLib.class"; + + /** + * The page rendering runtime. Registered by package rather than by name: a compiled page reaches + * all of it through Groovy, down to writing its output with an operator, and naming the types + * one at a time only ever describes the pages that have been rendered so far. + */ + private static final String[] RUNTIME_PATTERNS = { + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/gsp/**/*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/taglib/**/*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/buffer/**/*.class" + }; + + /** + * Whether the type, and the class declaring it, resolve on this classpath. The JSP integration + * is compiled against an API an application need not have, and registering a type the analysis + * then cannot parse fails the build rather than degrading at run time. + */ + private boolean resolves(String className, ClassLoader loader) { + int declaring = className.indexOf("$"); + if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), loader)) { + return false; + } + return ClassUtils.isPresent(className, loader); + } + + private static String[] patterns() { + String[] all = new String[RUNTIME_PATTERNS.length + 1]; + System.arraycopy(RUNTIME_PATTERNS, 0, all, 0, RUNTIME_PATTERNS.length); + all[RUNTIME_PATTERNS.length] = TAGLIB_PATTERN; + return all; + } + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); + ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); + MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver); + int registered = 0; + for (String pattern : patterns()) { + Resource[] resources; + try { + resources = resolver.getResources(pattern); + } + catch (IOException ex) { + logger.warn("Unable to scan for " + pattern, ex); + continue; + } + for (Resource resource : resources) { + String className; + try { + className = metadataReaderFactory.getMetadataReader(resource) + .getClassMetadata().getClassName(); + } + catch (IOException | RuntimeException ex) { + continue; + } + if (!resolves(className, loader)) { + continue; + } + // declared rather than public throughout: a tag's body may call a private helper on + // its own library, and a page reads the shared empty body as a field + hints.reflection().registerTypeIfPresent(loader, className, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, + MemberCategory.ACCESS_DECLARED_FIELDS, + MemberCategory.ACCESS_PUBLIC_FIELDS); + registered++; + } + } + logger.debug("Registered " + registered + " tag library and page runtime types"); + } +} diff --git a/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories b/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..e56c5b482c9 --- /dev/null +++ b/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.plugins.web.taglib.aot.TagLibRuntimeHints diff --git a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java b/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java new file mode 100644 index 00000000000..55d6b34999f --- /dev/null +++ b/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java @@ -0,0 +1,53 @@ +/* + * 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 grails.plugin.scaffolding.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * Registers the controller a scaffolded resource is served by. + * + *

    Its actions are reached through Groovy, including the protected ones it defines for the write + * operations, so an image that keeps only the members something asked for serves the pages and then + * fails on the request that saves or removes a record.

    + * + * @since 8.0 + */ +public class ScaffoldingRuntimeHints implements RuntimeHintsRegistrar { + + private static final String[] DISPATCHED_TYPES = { + "grails.plugin.scaffolding.RestfulServiceController", + "grails.plugin.scaffolding.ScaffoldingViewResolver", + "grails.plugin.scaffolding.annotation.Scaffold" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String type : DISPATCHED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, + MemberCategory.ACCESS_DECLARED_FIELDS); + } + } +} diff --git a/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories b/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..85ba8176d40 --- /dev/null +++ b/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +grails.plugin.scaffolding.aot.ScaffoldingRuntimeHints From 81ce34460a808255ffb38d694e15178e2a4eeea5 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 10:02:01 -0700 Subject: [PATCH 014/115] Register the classes a tag library declares inside itself Matching only the library by name left the classes it declares inside it stripped, so a page rendered until a tag reached one. The fields plugin keeps the bean stack that a nested tag reads its subject from in such a class, which is why a list or a form failed while the pages around them were fine. Found by driving the pages in a browser. An automated check that asks for a URL and looks at the status never nests a tag deeply enough to reach it. --- .../web/taglib/aot/TagLibRuntimeHints.java | 8 +- .../taglib/aot/TagLibRuntimeHintsSpec.groovy | 84 +++++++++++++++++++ 2 files changed, 90 insertions(+), 2 deletions(-) create mode 100644 grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java index 21c61db532a..919f3558722 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java @@ -52,9 +52,13 @@ public class TagLibRuntimeHints implements RuntimeHintsRegistrar { private static final Log logger = LogFactory.getLog(TagLibRuntimeHints.class); - /** A tag library is identified by its name, wherever it is declared. */ + /** + * A tag library is identified by its name, wherever it is declared. The trailing wildcard also + * takes the classes it declares inside itself: the fields plugin keeps the stack a nested tag + * reads its bean from in one, and a tag that never nests does not reach it. + */ private static final String TAGLIB_PATTERN = - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "**/*TagLib.class"; + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "**/*TagLib*.class"; /** * The page rendering runtime. Registered by package rather than by name: a compiled page reaches diff --git a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..2b63d2408a4 --- /dev/null +++ b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy @@ -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. + */ +package org.grails.plugins.web.taglib.aot + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +/** + * Covers the tag libraries and page runtime surviving into an ahead-of-time image. What a page + * reaches depends on what it renders, so a missing registration shows up on the page that uses that + * tag rather than at start-up. + */ +class TagLibRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new TagLibRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private Set registeredTypes() { + hints.reflection().typeHints().collect { it.type.name } as Set + } + + private boolean hasCategory(String type, MemberCategory category) { + def hint = hints.reflection().getTypeHint(TypeReference.of(type)) + hint != null && hint.memberCategories.contains(category) + } + + void 'the tag libraries on the classpath are registered'() { + expect: + registeredTypes().any { it.endsWith('TagLib') } + } + + void 'the classes a tag library declares inside itself are registered too'() { + expect: 'the fields plugin keeps the bean stack a nested tag reads in one of these, so a ' + + 'pattern matching only the library itself renders a page until a tag nests' + registeredTypes().any { it.contains('TagLib$') } + } + + void 'the page runtime a compiled page writes through is registered'() { + expect: + registeredTypes().any { it.startsWith('org.grails.gsp.') } + registeredTypes().any { it.startsWith('org.grails.buffer.') } + } + + void 'fields are registered, not only methods'() { + given: 'a page reads the shared empty body from the tag output rather than calling for it' + String type = registeredTypes().find { it.startsWith('org.grails.taglib.') } + + expect: + hasCategory(type, MemberCategory.ACCESS_DECLARED_FIELDS) + hasCategory(type, MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'a class loader that resolves nothing yields no hints rather than failing'() { + given: + RuntimeHints empty = new RuntimeHints() + + when: + new TagLibRuntimeHints().registerHints(empty, new URLClassLoader(new URL[0], null)) + + then: + noExceptionThrown() + } +} From f92e2e0cf814edd4172d9949838221ea76e07932 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 10:36:28 -0700 Subject: [PATCH 015/115] Use the pages compiled at build time in an ahead-of-time image Whether the pages compiled at build time are used is decided by whether a development environment is available, which comes down to whether the application looks like a project on disk. That is the right question for a running JVM, where skipping them lets an edit take effect without a restart. It is the wrong question for an ahead-of-time image. Such an image is a single executable that may be run from anywhere, including the directory it was built in, where the sources are still present and the answer is yes. It then read those sources and tried to compile them, which is the one thing it cannot do, so every page failed. Running the executable from somewhere else worked, which made this look like a property of the working directory rather than of the check. Both the plugin that loads the compiled page registry and the locator that reads it now also accept an image, which cannot compile a page whatever its surroundings suggest. Development is unchanged. The registry is loaded from a plugin descriptor, and a descriptor is Groovy, so the call that asks whether this is an image is itself dispatched dynamically and the class it is made on has to survive into the image. --- .../gsp/io/DefaultGroovyPageLocator.java | 26 +++- ...ultGroovyPageLocatorPrecompiledSpec.groovy | 125 ++++++++++++++++++ .../web/GroovyPagesGrailsPlugin.groovy | 8 +- .../web/taglib/aot/TagLibRuntimeHints.java | 13 ++ 4 files changed, 170 insertions(+), 2 deletions(-) create mode 100644 grails-gsp/core/src/test/groovy/org/grails/gsp/io/DefaultGroovyPageLocatorPrecompiledSpec.groovy diff --git a/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java b/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java index 04528d18247..1164f99960f 100644 --- a/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java +++ b/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java @@ -47,6 +47,8 @@ import grails.plugins.PluginManagerAware; import grails.util.CollectionUtils; import grails.util.Environment; + +import org.springframework.aot.AotDetector; import org.grails.gsp.GroovyPage; import org.grails.gsp.GroovyPageBinding; import org.grails.io.support.GrailsResourceUtils; @@ -410,8 +412,30 @@ protected Resource findResource(List searchPaths) { return foundResource; } + /** + * Whether the pages compiled at build time should be used. + * + *

    They are skipped in development so that editing a page takes effect without a restart, and + * that is decided by whether the application looks like a project on disk. An ahead-of-time + * image can look like one -- it is a single executable that may be run from anywhere, including + * the directory it was built in -- but it cannot compile a page at run time, because it cannot + * define a class at all. Reading the sources there renders nothing, so the compiled pages are + * used whatever the surroundings suggest.

    + */ private boolean isPrecompiledAvailable() { - return precompiledGspMap != null && precompiledGspMap.size() > 0 && !Environment.isDevelopmentMode(); + if (precompiledGspMap == null || precompiledGspMap.isEmpty()) { + return false; + } + return !isDevelopmentMode() || AotDetector.useGeneratedArtifacts(); + } + + /** + * Whether the application is being developed, which is decided by whether it looks like a project + * on disk. Overridable because that is derived from the working directory when the class is + * loaded, and so cannot be varied any other way. + */ + protected boolean isDevelopmentMode() { + return Environment.isDevelopmentMode(); } public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { diff --git a/grails-gsp/core/src/test/groovy/org/grails/gsp/io/DefaultGroovyPageLocatorPrecompiledSpec.groovy b/grails-gsp/core/src/test/groovy/org/grails/gsp/io/DefaultGroovyPageLocatorPrecompiledSpec.groovy new file mode 100644 index 00000000000..5c586afd413 --- /dev/null +++ b/grails-gsp/core/src/test/groovy/org/grails/gsp/io/DefaultGroovyPageLocatorPrecompiledSpec.groovy @@ -0,0 +1,125 @@ +/* + * 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.grails.gsp.io + +import grails.util.Environment + +import org.springframework.aot.AotDetector +import spock.lang.Specification + +/** + * Covers which pages are used when the application looks like a project on disk. + * + *

    Development skips the pages compiled at build time so that editing one takes effect without a + * restart. An ahead-of-time image can look the same -- it is a single executable, and it may be run + * from the directory it was built in -- but it cannot compile a page at run time, so reading the + * sources renders nothing.

    + */ +class DefaultGroovyPageLocatorPrecompiledSpec extends Specification { + + private static final String VIEW = '/views/index.gsp' + + DefaultGroovyPageLocator locator = new DefaultGroovyPageLocator() + + void setup() { + locator.setPrecompiledGspMap([(VIEW): CompiledPage.name]) + } + + private static final String AOT_KEY = 'spring.aot.enabled' + + /** Restores the property, so the environment other specs observe is unchanged. */ + private void withAot(boolean aot, Closure body) { + String previous = System.getProperty(AOT_KEY) + try { + aot ? System.setProperty(AOT_KEY, 'true') : System.clearProperty(AOT_KEY) + body.call() + } + finally { + previous == null ? System.clearProperty(AOT_KEY) : System.setProperty(AOT_KEY, previous) + } + } + + /** A locator that believes it is looking at a project on disk, which the filesystem decides. */ + private DefaultGroovyPageLocator developmentLocator() { + def developing = new DefaultGroovyPageLocator() { + @Override + protected boolean isDevelopmentMode() { true } + } + developing.setPrecompiledGspMap([(VIEW): CompiledPage.name]) + developing + } + + void 'a compiled page is used when the application is not a project on disk'() { + when: + def source = null + withAot(false) { source = locator.findPage(VIEW) } + + then: + source instanceof GroovyPageCompiledScriptSource + } + + void 'a compiled page is used in an ahead-of-time image even though it looks like development'() { + when: 'the executable is run from the directory it was built in' + def source = null + withAot(true) { source = developmentLocator().findPage(VIEW) } + + then: 'reading the sources would render nothing, because no class can be defined' + source instanceof GroovyPageCompiledScriptSource + } + + void 'development still prefers the sources so that an edit takes effect'() { + when: + def source = null + withAot(false) { source = developmentLocator().findPage(VIEW) } + + then: 'no source file exists here, so nothing is found rather than the compiled page' + !(source instanceof GroovyPageCompiledScriptSource) + } + + /** + * Stands in for a page the build compiled. The constants are the ones the compiler emits and the + * page's metadata is read from, so the locator can treat this like any other compiled page. + */ + static class CompiledPage extends org.grails.gsp.GroovyPage { + + public static final String CONTENT_TYPE = 'text/html;charset=UTF-8' + + public static final Map JSP_TAGS = [:] + + public static final Long LAST_MODIFIED = 0L + + public static final String EXPRESSION_CODEC = 'html' + + public static final String STATIC_CODEC = 'none' + + public static final String OUT_CODEC = 'none' + + public static final String TAGLIB_CODEC = 'none' + + @Override + String getGroovyPageFileName() { + 'index.gsp' + } + + @Override + Object run() { + null + } + } +} diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index f3a08dbe0a1..f53d4ffeb32 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -21,6 +21,7 @@ package org.grails.plugins.web import groovy.transform.CompileStatic import groovy.util.logging.Slf4j +import org.springframework.aot.AotDetector import org.springframework.beans.factory.config.PropertiesFactoryBean import org.springframework.boot.web.servlet.ServletRegistrationBean import org.springframework.core.io.Resource @@ -166,7 +167,12 @@ class GroovyPagesGrailsPlugin extends Plugin { } } - def deployed = !Metadata.getCurrent().isDevelopmentEnvironmentAvailable() + // An ahead-of-time image reads the pages compiled at build time whatever its + // surroundings suggest. It can be run from the directory it was built in, where a + // development environment is available, and it still cannot compile a page: defining a + // class at run time is what such an image gives up. + def deployed = !Metadata.getCurrent().isDevelopmentEnvironmentAvailable() || + AotDetector.useGeneratedArtifacts() groovyPageLocator(CachingGrailsConventionGroovyPageLocator) { bean -> bean.lazyInit = true if (customResourceLoader) { diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java index 919f3558722..0038eea57a3 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java @@ -91,9 +91,22 @@ private static String[] patterns() { return all; } + /** + * Types the plugin descriptors call. A descriptor is Groovy, so even a static call on a utility + * class is dispatched dynamically and needs the class to survive. + */ + private static final String[] CALLED_FROM_DESCRIPTORS = { + "org.springframework.aot.AotDetector" + }; + @Override public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); + for (String type : CALLED_FROM_DESCRIPTORS) { + hints.reflection().registerTypeIfPresent(loader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS); + } ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver); int registered = 0; From d3668417074a736041f847d3b8ebebfc44a496c6 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 11:31:18 -0700 Subject: [PATCH 016/115] Ask one question about which scanned types may be registered Each registrar decided for itself whether a type it found could be kept, and the two checks that decision needs were rediscovered a piece at a time, wrongly, three times over. Registering a type that cannot be loaded does not degrade at run time: it fails the image build, because the analysis parses what it is asked to keep. Either check alone lets one case through, which is what made this easy to get wrong. Whether the type and the class declaring it load covers a closure whose enclosing class extends something absent, which the closure never names itself because it reaches it through invokedynamic. Whether the types its bytecode names load covers the opposite, a class that loads cleanly while a method body names an absent one, because loading resolves signatures and not bodies. Both now live with the reason each exists, where a registrar for a new part of the framework will find them. --- .../org/grails/aot/RegistrableTypes.java | 154 ++++++++++++++++++ .../grails/aot/RegistrableTypesSpec.groovy | 84 ++++++++++ .../beans/aot/GrailsClosureRuntimeHints.java | 117 ++----------- .../datastore/gorm/aot/GormRuntimeHints.java | 16 +- .../web/taglib/aot/TagLibRuntimeHints.java | 17 +- 5 files changed, 262 insertions(+), 126 deletions(-) create mode 100644 grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java create mode 100644 grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy diff --git a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java b/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java new file mode 100644 index 00000000000..37055a3bc99 --- /dev/null +++ b/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java @@ -0,0 +1,154 @@ +/* + * 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.grails.aot; + +import java.io.IOException; +import java.io.InputStream; +import java.util.LinkedHashSet; +import java.util.Set; + +import org.springframework.asm.ClassReader; +import org.springframework.asm.ClassVisitor; +import org.springframework.asm.MethodVisitor; +import org.springframework.asm.SpringAsmInfo; +import org.springframework.asm.Type; +import org.springframework.lang.Nullable; +import org.springframework.util.ClassUtils; + +/** + * Decides whether a type found by scanning can be registered for reflection. + * + *

    Registering one that cannot be loaded here does not degrade at run time -- it fails the build, + * because the image analysis parses what it is asked to keep. The framework compiles against + * optional integrations, so a scan of its own packages finds classes an application need not be able + * to load: the JSP support without the JSP API, the GSP compiler's task without Ant, a datastore + * without its driver.

    + * + *

    Two questions are asked, because either alone lets one of those through. Whether the type and + * the class declaring it load covers a closure whose enclosing class extends something absent, which + * the closure's own bytecode need not name -- it reaches it through invokedynamic. Whether the types + * its bytecode names load covers the opposite case, a class that loads cleanly while a method body + * names something absent, because loading resolves signatures and not bodies.

    + * + * @since 8.0 + */ +public final class RegistrableTypes { + + private RegistrableTypes() { + } + + /** + * Whether the type, and the class declaring it, load here. + * + * @param className the binary name of the type + * @param classLoader the loader to resolve against + * @return whether the type can be registered + */ + public static boolean loads(String className, @Nullable ClassLoader classLoader) { + int declaring = className.indexOf('$'); + if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), classLoader)) { + return false; + } + return ClassUtils.isPresent(className, classLoader); + } + + /** + * Whether every type named in the given bytecode loads here, following the declaration and the + * bodies of the methods. + * + * @param bytecode the class file to read; closed by this method + * @param classLoader the loader to resolve against + * @return whether the type can be registered + */ + public static boolean referencesLoad(InputStream bytecode, @Nullable ClassLoader classLoader) { + Set referenced = new LinkedHashSet<>(); + try (InputStream input = bytecode) { + new ClassReader(input).accept(new ReferenceCollector(referenced), + ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); + } + catch (IOException | RuntimeException ex) { + return false; + } + for (String name : referenced) { + if (!ClassUtils.isPresent(name, classLoader)) { + return false; + } + } + return true; + } + + /** Collects the types a class names, in its own declaration and in the bodies of its methods. */ + private static final class ReferenceCollector extends ClassVisitor { + + private final Set referenced; + + private ReferenceCollector(Set referenced) { + super(SpringAsmInfo.ASM_VERSION); + this.referenced = referenced; + } + + private void add(@Nullable String internalName) { + if (internalName == null || internalName.startsWith("[")) { + return; + } + String className = ClassUtils.convertResourcePathToClassName(internalName); + // the JDK is always present, and skipping it keeps this to the classes that can be absent + if (!className.startsWith("java.") && !className.startsWith("jdk.")) { + referenced.add(className); + } + } + + @Override + public void visit(int version, int access, String name, String signature, String superName, + String[] interfaces) { + add(superName); + if (interfaces != null) { + for (String each : interfaces) { + add(each); + } + } + } + + @Override + public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, + String[] exceptions) { + for (Type argument : Type.getArgumentTypes(descriptor)) { + add(argument.getSort() == Type.OBJECT ? argument.getInternalName() : null); + } + return new MethodVisitor(SpringAsmInfo.ASM_VERSION) { + @Override + public void visitTypeInsn(int opcode, String type) { + add(type); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String methodName, + String methodDescriptor, boolean isInterface) { + add(owner); + } + + @Override + public void visitFieldInsn(int opcode, String owner, String fieldName, + String fieldDescriptor) { + add(owner); + } + }; + } + } +} diff --git a/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy b/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy new file mode 100644 index 00000000000..35953fcab68 --- /dev/null +++ b/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy @@ -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. + */ +package org.grails.aot + +import spock.lang.Specification + +/** + * Covers which scanned types may be registered for reflection. Registering one that cannot be loaded + * fails the image build rather than degrading at run time, which is why this is asked at all. + */ +class RegistrableTypesSpec extends Specification { + + ClassLoader loader = getClass().classLoader + + private InputStream bytecodeOf(Class type) { + loader.getResourceAsStream(type.name.replace('.', '/') + '.class') + } + + void 'a type that loads may be registered'() { + expect: + RegistrableTypes.loads('java.lang.String', loader) + } + + void 'a type that is absent may not'() { + expect: + !RegistrableTypes.loads('com.example.NotOnTheClasspath', loader) + } + + void 'a nested type whose declaring class is absent may not'() { + expect: 'this is the closure whose enclosing class extends something absent, which the ' + + 'closure reaches through invokedynamic and so never names itself' + !RegistrableTypes.loads('com.example.Missing$_run_closure1', loader) + } + + void 'a nested type whose declaring class loads may be'() { + expect: + RegistrableTypes.loads(Outer.Inner.name, loader) + } + + void 'bytecode naming only types that load may be registered'() { + expect: + RegistrableTypes.referencesLoad(bytecodeOf(Outer), loader) + } + + void 'bytecode is rejected when it cannot be read'() { + expect: + !RegistrableTypes.referencesLoad(new ByteArrayInputStream('not a class'.bytes), loader) + } + + void 'a class loader without the framework on it accepts none of its types'() { + given: 'a bootstrap-only loader, which still has the JDK but nothing else' + ClassLoader empty = new URLClassLoader(new URL[0], null) + + expect: + !RegistrableTypes.loads(RegistrableTypes.name, empty) + RegistrableTypes.loads('java.lang.String', empty) + } + + static class Outer { + + String describe() { + new Inner().toString() + } + + static class Inner { + } + } +} diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java index 35f5b9e5bed..376b85c37a4 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -19,18 +19,12 @@ package org.grails.spring.beans.aot; import java.io.IOException; -import java.io.InputStream; -import java.util.LinkedHashSet; -import java.util.Set; + +import org.grails.aot.RegistrableTypes; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.springframework.asm.ClassReader; -import org.springframework.asm.SpringAsmInfo; -import org.springframework.asm.ClassVisitor; -import org.springframework.asm.MethodVisitor; -import org.springframework.asm.Type; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; @@ -93,7 +87,7 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) } for (Resource resource : resources) { String className = classNameOf(metadataReaderFactory, resource); - if (className != null && resolves(className, resource, loader)) { + if (className != null && registrable(className, resource, loader)) { hints.reflection().registerTypeIfPresent(loader, className, MemberCategory.INVOKE_DECLARED_METHODS, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); @@ -104,106 +98,31 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) logger.debug("Registered " + registered + " Grails closures for reflection"); } - @Nullable - private String classNameOf(MetadataReaderFactory factory, Resource resource) { - try { - return factory.getMetadataReader(resource).getClassMetadata().getClassName(); - } - catch (IOException | RuntimeException ex) { - return null; - } - } - /** - * Whether every class the closure names resolves on this classpath. - * - *

    Loading the class is not enough: that resolves its declaration and the types in its method - * signatures, but not the ones its bodies reference, and the image analysis parses those bodies. - * The GSP compiler's JSP closures link happily against a runtime with no JSP API and then fail - * the build, so the references are read directly instead.

    + * Whether the closure can be kept. Both questions are asked: the GSP compiler's task extends an + * Ant type absent at run time and its closures reach it through invokedynamic, so nothing in + * their own bytecode reveals it, while the JSP closures load cleanly and name an absent class in + * a method body. */ - private boolean resolves(String className, Resource resource, ClassLoader loader) { - // A closure cannot be reached unless the class declaring it can be: the GSP compiler's task - // extends an Ant type that is absent at run time, and its closures reach it through - // invokedynamic, so the reference is not visible in the bytecode read below. - int declaring = className.indexOf("$_"); - if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), loader)) { - logger.trace("Skipping closure whose declaring class does not resolve: " + className); + private boolean registrable(String className, Resource resource, ClassLoader loader) { + if (!RegistrableTypes.loads(className, loader)) { return false; } - Set referenced = new LinkedHashSet<>(); - try (InputStream input = resource.getInputStream()) { - new ClassReader(input).accept(new ReferenceCollector(referenced), - ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); + try { + return RegistrableTypes.referencesLoad(resource.getInputStream(), loader); } - catch (IOException | RuntimeException ex) { + catch (IOException ex) { return false; } - for (String name : referenced) { - if (!ClassUtils.isPresent(name, loader)) { - logger.trace("Skipping closure referencing " + name + ", absent from this classpath"); - return false; - } - } - return true; } - /** Collects the types a class names, in its own declaration and in the bodies of its methods. */ - private static final class ReferenceCollector extends ClassVisitor { - - private final Set referenced; - - private ReferenceCollector(Set referenced) { - super(SpringAsmInfo.ASM_VERSION); - this.referenced = referenced; - } - - private void add(@Nullable String internalName) { - if (internalName == null || internalName.startsWith("[")) { - return; - } - String className = ClassUtils.convertResourcePathToClassName(internalName); - // the JDK is always present, and skipping it keeps this to the classes that can be absent - if (!className.startsWith("java.") && !className.startsWith("jdk.")) { - referenced.add(className); - } - } - - @Override - public void visit(int version, int access, String name, String signature, String superName, - String[] interfaces) { - add(superName); - if (interfaces != null) { - for (String each : interfaces) { - add(each); - } - } + @Nullable + private String classNameOf(MetadataReaderFactory factory, Resource resource) { + try { + return factory.getMetadataReader(resource).getClassMetadata().getClassName(); } - - @Override - public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, - String[] exceptions) { - for (Type argument : Type.getArgumentTypes(descriptor)) { - add(argument.getSort() == Type.OBJECT ? argument.getInternalName() : null); - } - return new MethodVisitor(SpringAsmInfo.ASM_VERSION) { - @Override - public void visitTypeInsn(int opcode, String type) { - add(type); - } - - @Override - public void visitMethodInsn(int opcode, String owner, String methodName, - String methodDescriptor, boolean isInterface) { - add(owner); - } - - @Override - public void visitFieldInsn(int opcode, String owner, String fieldName, - String fieldDescriptor) { - add(owner); - } - }; + catch (IOException | RuntimeException ex) { + return null; } } diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java index 2d76b6038f9..ba9d26c6b48 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java @@ -20,6 +20,8 @@ import java.io.IOException; +import org.grails.aot.RegistrableTypes; + import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -92,7 +94,7 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) catch (IOException | RuntimeException ex) { continue; } - if (!resolves(className, loader)) { + if (!RegistrableTypes.loads(className, loader)) { continue; } hints.reflection().registerTypeIfPresent(loader, className, @@ -107,16 +109,4 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) logger.debug("Registered " + registered + " persistence runtime types for reflection"); } - /** - * Whether the type, and the class declaring it, resolve here. A datastore compiles against a - * driver an application need not have, and registering a type the image analysis then cannot - * parse fails the build rather than degrading at run time. - */ - private boolean resolves(String className, ClassLoader loader) { - int declaring = className.indexOf('$'); - if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), loader)) { - return false; - } - return ClassUtils.isPresent(className, loader); - } } diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java index 0038eea57a3..30a5e413d73 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java @@ -20,6 +20,8 @@ import java.io.IOException; +import org.grails.aot.RegistrableTypes; + import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -71,19 +73,6 @@ public class TagLibRuntimeHints implements RuntimeHintsRegistrar { ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/buffer/**/*.class" }; - /** - * Whether the type, and the class declaring it, resolve on this classpath. The JSP integration - * is compiled against an API an application need not have, and registering a type the analysis - * then cannot parse fails the build rather than degrading at run time. - */ - private boolean resolves(String className, ClassLoader loader) { - int declaring = className.indexOf("$"); - if (declaring > 0 && !ClassUtils.isPresent(className.substring(0, declaring), loader)) { - return false; - } - return ClassUtils.isPresent(className, loader); - } - private static String[] patterns() { String[] all = new String[RUNTIME_PATTERNS.length + 1]; System.arraycopy(RUNTIME_PATTERNS, 0, all, 0, RUNTIME_PATTERNS.length); @@ -128,7 +117,7 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) catch (IOException | RuntimeException ex) { continue; } - if (!resolves(className, loader)) { + if (!RegistrableTypes.loads(className, loader)) { continue; } // declared rather than public throughout: a tag's body may call a private helper on From e1e3aae3a38c504efd3346ca2c7d486fd2b24d60 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 11:44:14 -0700 Subject: [PATCH 017/115] Cover what an application records for an ahead-of-time image The task had no tests. Two of these cover what went wrong while it was being written: the pages a plugin contributes, whose absence stopped an application starting because it renders those as readily as its own, and the rule that the manifest rather than the directory listing decides which pages exist, so a class left behind by an earlier build is not recorded. --- .../aot/GenerateNativeMetadataTaskSpec.groovy | 182 ++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy new file mode 100644 index 00000000000..6a26597ecd9 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy @@ -0,0 +1,182 @@ +/* + * 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.grails.gradle.plugin.aot + +import java.util.jar.JarEntry +import java.util.jar.JarOutputStream + +import groovy.json.JsonSlurper +import spock.lang.Specification +import spock.lang.TempDir + +import org.gradle.api.Project +import org.gradle.testfixtures.ProjectBuilder + +class GenerateNativeMetadataTaskSpec extends Specification { + + @TempDir + File projectDir + + private File classesDir + private File pageClassesDir + + void setup() { + classesDir = new File(projectDir, 'classes') + pageClassesDir = new File(projectDir, 'gsp-classes') + classesDir.mkdirs() + pageClassesDir.mkdirs() + } + + private void writeClass(File root, String path) { + File target = new File(root, path + '.class') + target.parentFile.mkdirs() + target.bytes = new byte[]{ (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE } + } + + /** Writes the manifest the GSP compiler produces, mapping a view to the class it compiled to. */ + private void writeViewsManifest(File root, Map views) { + File manifest = new File(root, GenerateNativeMetadataTask.VIEWS_MANIFEST) + manifest.parentFile.mkdirs() + Properties properties = new Properties() + views.each { String uri, String pageClass -> properties.setProperty(uri, pageClass) } + manifest.withOutputStream { properties.store(it, null) } + } + + /** A jar shaped like the one a plugin publishes, carrying its own pages. */ + private File writePluginJar(String name, Map views) { + File jar = new File(projectDir, name) + Properties properties = new Properties() + views.each { String uri, String pageClass -> properties.setProperty(uri, pageClass) } + new JarOutputStream(jar.newOutputStream()).withCloseable { JarOutputStream out -> + out.putNextEntry(new JarEntry(GenerateNativeMetadataTask.VIEWS_MANIFEST)) + properties.store(out, null) + out.closeEntry() + views.values().each { String pageClass -> + out.putNextEntry(new JarEntry(pageClass + '.class')) + out.write([0xCA, 0xFE, 0xBA, 0xBE] as byte[]) + out.closeEntry() + } + } + jar + } + + private GenerateNativeMetadataTask task(List classpath = []) { + Project project = ProjectBuilder.builder().withProjectDir(projectDir).build() + project.tasks.register('generateNativeMetadata', GenerateNativeMetadataTask) { + GenerateNativeMetadataTask it -> + it.classesDirs.from(classesDir) + it.pageClassesDirs.from(pageClassesDir) + it.pageClasspath.from(classpath) + it.outputDirectory.set(new File(projectDir, 'out')) + } + project.tasks.named('generateNativeMetadata', GenerateNativeMetadataTask).get() + } + + private List recordedTypes(GenerateNativeMetadataTask task) { + task.generate() + File file = new File(task.outputDirectory.get().asFile, GenerateNativeMetadataTask.METADATA_PATH) + file.exists() ? new JsonSlurper().parse(file).reflection.collect { it.type } : [] + } + + void 'the application classes are recorded'() { + given: + writeClass(classesDir, 'com/example/UserController') + writeClass(classesDir, 'com/example/User') + + expect: + recordedTypes(task()).containsAll(['com.example.UserController', 'com.example.User']) + } + + void 'the closures an artefact declares are recorded'() { + given: 'Groovy reads doCall reflectively to pick an overload, so these are reached too' + writeClass(classesDir, 'com/example/BootStrap$_closure1') + + expect: + recordedTypes(task()).contains('com.example.BootStrap$_closure1') + } + + void 'a page is recorded under the class its view compiled to'() { + given: + writeViewsManifest(pageClassesDir, ['/WEB-INF/grails-app/views/index.gsp': 'gsp_app_index_gsp']) + writeClass(pageClassesDir, 'gsp_app_index_gsp') + + expect: + recordedTypes(task()).contains('gsp_app_index_gsp') + } + + void 'the closures a page declares are recorded'() { + given: + writeViewsManifest(pageClassesDir, ['/WEB-INF/grails-app/views/index.gsp': 'gsp_app_index_gsp']) + writeClass(pageClassesDir, 'gsp_app_index_gsp') + writeClass(pageClassesDir, 'gsp_app_index_gsp$_run_closure1') + + expect: + recordedTypes(task()).contains('gsp_app_index_gsp$_run_closure1') + } + + void 'a page class left behind by an earlier build is not recorded'() { + given: 'the manifest is the record of this build, the directory is not' + writeViewsManifest(pageClassesDir, ['/WEB-INF/grails-app/views/index.gsp': 'gsp_app_index_gsp']) + writeClass(pageClassesDir, 'gsp_app_index_gsp') + writeClass(pageClassesDir, 'gsp_app_removed_gsp') + + expect: + !recordedTypes(task()).contains('gsp_app_removed_gsp') + } + + void 'the pages a plugin contributes are recorded'() { + given: 'an application renders these as readily as its own, and they are not in its build' + File pluginJar = writePluginJar('fields-plugin.jar', + ['/WEB-INF/grails-app/views/_fields/default/_field.gsp': 'gsp_fields_field_gsp']) + + expect: + recordedTypes(task([pluginJar])).contains('gsp_fields_field_gsp') + } + + void 'an artifact carrying no pages is passed over'() { + given: + File plainJar = new File(projectDir, 'plain.jar') + new JarOutputStream(plainJar.newOutputStream()).withCloseable { JarOutputStream out -> + out.putNextEntry(new JarEntry('com/example/Plain.class')) + out.write([0xCA, 0xFE, 0xBA, 0xBE] as byte[]) + out.closeEntry() + } + writeClass(classesDir, 'com/example/UserController') + + when: + def types = recordedTypes(task([plainJar])) + + then: + noExceptionThrown() + types == ['com.example.UserController'] + } + + void 'every recorded type is registered for the access Grails makes of it'() { + given: + writeClass(classesDir, 'com/example/UserController') + + when: + def task = task() + task.generate() + def entries = new JsonSlurper() + .parse(new File(task.outputDirectory.get().asFile, GenerateNativeMetadataTask.METADATA_PATH)) + .reflection + + then: 'an action is invoked by name, and a domain class has its properties read' + entries.every { it.allDeclaredMethods && it.allDeclaredFields && it.allDeclaredConstructors } + } +} From 29053d5f2df176e07557d8cc42b62279718914c2 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 12:21:24 -0700 Subject: [PATCH 018/115] Follow the configured import order and indentation The registrars were written without the style checks having been run, and they indented array initialisers one level too far and put their imports in the wrong group. Behaviour is unchanged. --- .../aot/ControllerRuntimeHints.java | 18 +++++++++--------- .../beans/aot/GrailsClosureRuntimeHints.java | 11 +++++------ .../datastore/gorm/aot/GormRuntimeHints.java | 8 ++++---- .../gsp/io/DefaultGroovyPageLocator.java | 3 +-- .../web/taglib/aot/TagLibRuntimeHints.java | 12 ++++++------ .../web/mime/aot/MimeTypeRuntimeHints.java | 6 +++--- .../aot/ScaffoldingRuntimeHints.java | 6 +++--- .../aot/DataBindingRuntimeHints.java | 16 ++++++++-------- .../mapping/aot/UrlMappingRuntimeHints.java | 12 ++++++------ 9 files changed, 45 insertions(+), 47 deletions(-) diff --git a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java b/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java index e37c7730d98..8263cb525d5 100644 --- a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java +++ b/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java @@ -45,15 +45,15 @@ public class ControllerRuntimeHints implements RuntimeHintsRegistrar { * when present, so this stays correct for an application that does not use every plugin. */ private static final String[] DISPATCHED_TYPES = { - "grails.artefact.Controller", - "grails.artefact.controller.support.AllowedMethodsHelper", - "grails.artefact.controller.support.RequestForwarder", - "grails.artefact.controller.support.ResponseRedirector", - "grails.artefact.controller.support.ResponseRenderer", - "grails.artefact.controller.RestResponder", - // a view asking who is logged in reaches the request's principal, and Groovy makes that - // call on the interface rather than the implementation the container supplies - "java.security.Principal" + "grails.artefact.Controller", + "grails.artefact.controller.support.AllowedMethodsHelper", + "grails.artefact.controller.support.RequestForwarder", + "grails.artefact.controller.support.ResponseRedirector", + "grails.artefact.controller.support.ResponseRenderer", + "grails.artefact.controller.RestResponder", + // a view asking who is logged in reaches the request's principal, and Groovy makes that + // call on the interface rather than the implementation the container supplies + "java.security.Principal" }; @Override diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java index 376b85c37a4..68b972ea5b8 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -20,12 +20,9 @@ import java.io.IOException; -import org.grails.aot.RegistrableTypes; - import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; - import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; @@ -37,6 +34,8 @@ import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; +import org.grails.aot.RegistrableTypes; + /** * Registers the framework closures Groovy dispatches through. * @@ -65,9 +64,9 @@ public class GrailsClosureRuntimeHints implements RuntimeHintsRegistrar { * the container calls while the context is built. */ private static final String[] PATTERNS = { - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "grails/**/*_closure*.class", - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/**/*_closure*.class", - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "**/*GrailsPlugin$*_closure*.class" + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "grails/**/*_closure*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/**/*_closure*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "**/*GrailsPlugin$*_closure*.class" }; @Override diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java index ba9d26c6b48..911adaaa1f2 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java @@ -20,8 +20,6 @@ import java.io.IOException; -import org.grails.aot.RegistrableTypes; - import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -36,6 +34,8 @@ import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; +import org.grails.aot.RegistrableTypes; + /** * Registers the persistence runtime a datastore reaches through Groovy. * @@ -66,8 +66,8 @@ public class GormRuntimeHints implements RuntimeHintsRegistrar { * the operations that have been run so far, and every datastore adds its own. */ private static final String[] PATTERNS = { - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/datastore/mapping/**/*.class", - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/datastore/gorm/**/*.class" + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/datastore/mapping/**/*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/datastore/gorm/**/*.class" }; @Override diff --git a/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java b/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java index 1164f99960f..c99b7d0431b 100644 --- a/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java +++ b/grails-gsp/core/src/main/groovy/org/grails/gsp/io/DefaultGroovyPageLocator.java @@ -34,6 +34,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.springframework.aot.AotDetector; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; @@ -47,8 +48,6 @@ import grails.plugins.PluginManagerAware; import grails.util.CollectionUtils; import grails.util.Environment; - -import org.springframework.aot.AotDetector; import org.grails.gsp.GroovyPage; import org.grails.gsp.GroovyPageBinding; import org.grails.io.support.GrailsResourceUtils; diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java index 30a5e413d73..a9c890cf051 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java @@ -20,8 +20,6 @@ import java.io.IOException; -import org.grails.aot.RegistrableTypes; - import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -36,6 +34,8 @@ import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; +import org.grails.aot.RegistrableTypes; + /** * Registers the tag libraries and page runtime a rendered page dispatches through. * @@ -68,9 +68,9 @@ public class TagLibRuntimeHints implements RuntimeHintsRegistrar { * one at a time only ever describes the pages that have been rendered so far. */ private static final String[] RUNTIME_PATTERNS = { - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/gsp/**/*.class", - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/taglib/**/*.class", - ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/buffer/**/*.class" + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/gsp/**/*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/taglib/**/*.class", + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "org/grails/buffer/**/*.class" }; private static String[] patterns() { @@ -85,7 +85,7 @@ private static String[] patterns() { * class is dispatched dynamically and needs the class to survive. */ private static final String[] CALLED_FROM_DESCRIPTORS = { - "org.springframework.aot.AotDetector" + "org.springframework.aot.AotDetector" }; @Override diff --git a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java b/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java index de6c2005a50..f519809a210 100644 --- a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java +++ b/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java @@ -39,9 +39,9 @@ public class MimeTypeRuntimeHints implements RuntimeHintsRegistrar { * correct for an application that does not use every plugin. */ private static final String[] DISPATCHED_TYPES = { - "grails.web.mime.MimeType", - "org.grails.web.mime.DefaultAcceptHeaderParser", - "org.grails.web.mime.DefaultMimeUtility" + "grails.web.mime.MimeType", + "org.grails.web.mime.DefaultAcceptHeaderParser", + "org.grails.web.mime.DefaultMimeUtility" }; @Override diff --git a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java b/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java index 55d6b34999f..7a063c4e760 100644 --- a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java +++ b/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java @@ -35,9 +35,9 @@ public class ScaffoldingRuntimeHints implements RuntimeHintsRegistrar { private static final String[] DISPATCHED_TYPES = { - "grails.plugin.scaffolding.RestfulServiceController", - "grails.plugin.scaffolding.ScaffoldingViewResolver", - "grails.plugin.scaffolding.annotation.Scaffold" + "grails.plugin.scaffolding.RestfulServiceController", + "grails.plugin.scaffolding.ScaffoldingViewResolver", + "grails.plugin.scaffolding.annotation.Scaffold" }; @Override diff --git a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java b/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java index 4c617da1598..35ba34149e9 100644 --- a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java +++ b/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java @@ -39,14 +39,14 @@ public class DataBindingRuntimeHints implements RuntimeHintsRegistrar { * correct for an application that does not use every plugin. */ private static final String[] DISPATCHED_TYPES = { - "grails.web.databinding.WebDataBinding", - "grails.web.databinding.DataBindingUtils", - "grails.databinding.DataBindingSource", - "grails.databinding.BindingHelper", - "grails.databinding.converters.ValueConverter", - // binding asks a target type whether it is an array, and Groovy makes that call - // reflectively on the Class object rather than directly - "java.lang.Class" + "grails.web.databinding.WebDataBinding", + "grails.web.databinding.DataBindingUtils", + "grails.databinding.DataBindingSource", + "grails.databinding.BindingHelper", + "grails.databinding.converters.ValueConverter", + // binding asks a target type whether it is an array, and Groovy makes that call + // reflectively on the Class object rather than directly + "java.lang.Class" }; @Override diff --git a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java b/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java index b716a43f78a..fa36d4bf680 100644 --- a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java +++ b/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java @@ -40,12 +40,12 @@ public class UrlMappingRuntimeHints implements RuntimeHintsRegistrar { * correct for an application that does not use every plugin. */ private static final String[] DISPATCHED_TYPES = { - "grails.web.mapping.UrlMappingInfo", - "grails.web.mapping.UrlMapping", - "grails.web.mapping.UrlMappings", - "grails.web.mapping.UrlCreator", - "grails.web.mapping.LinkGenerator", - "grails.web.mapping.UrlMappingData" + "grails.web.mapping.UrlMappingInfo", + "grails.web.mapping.UrlMapping", + "grails.web.mapping.UrlMappings", + "grails.web.mapping.UrlCreator", + "grails.web.mapping.LinkGenerator", + "grails.web.mapping.UrlMappingData" }; @Override From 22c100bdb21e658d8a0aeb1b86adae3bf2ee8a90 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 14:00:57 -0700 Subject: [PATCH 019/115] Expand scaffolded views only where a controller is scaffolded The expansion staged the views into a directory and pointed the compilation there, for every project. A project with no scaffolded controller then copied its views on every build and compiled them from somewhere other than where they are, for nothing. Whether anything is scaffolded is read from the controller sources, because the decision is needed before anything has been compiled. A project that does not scaffold is left exactly as it was. --- .../plugin/views/gsp/GroovyPagePlugin.groovy | 103 ++++++++++++------ 1 file changed, 67 insertions(+), 36 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy index fee4e659457..60945e07d69 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy @@ -73,52 +73,64 @@ class GroovyPagePlugin implements Plugin { ].findAll { it } ) - // Scaffolded views are expanded from their templates here and staged alongside the - // application's own, so a single compile produces a single gsp/views.properties. Compiling - // them separately would produce a second manifest, and the jar's duplicate handling would - // silently keep only one of them. - Provider stagedViews = project.layout.buildDirectory.dir('generated/views') - def generateScaffoldedViews = tasks.register( - 'generateScaffoldedViews', GenerateScaffoldedViewsTask) { GenerateScaffoldedViewsTask it -> - it.group = BasePlugin.BUILD_GROUP - it.description = 'Expands the views of scaffolded controllers so they can be precompiled' - // the classes directory is written by more than one task, so the dependency is stated - // against the compilation rather than inferred from the directory - it.dependsOn(tasks.named('compileJava')) - ['compileGroovy', 'copyAstClasses'].each { String name -> - if (project.tasks.findByName(name)) { - it.dependsOn(tasks.named(name)) + // A scaffolded controller has no views of its own, so they are expanded from their + // templates and compiled with the rest. They are staged together rather than compiled + // separately, because a second compilation writes a second gsp/views.properties and the + // archive tasks discard duplicates, losing the views one of them lists. + // + // Only a project that scaffolds pays for this. Staging copies the views, and pointing the + // compilation at the copy would change what every other project compiles for no reason. + Directory appViews = project.layout.projectDirectory.dir('grails-app/views') + boolean scaffolds = scaffoldsAnyController(project) + + Directory viewsToCompile = appViews + if (scaffolds) { + Provider stagedViews = project.layout.buildDirectory.dir('generated/views') + def generateScaffoldedViews = tasks.register( + 'generateScaffoldedViews', GenerateScaffoldedViewsTask) { GenerateScaffoldedViewsTask it -> + it.group = BasePlugin.BUILD_GROUP + it.description = 'Expands the views of scaffolded controllers so they can be precompiled' + // the classes directory is written by more than one task, so the dependency is stated + // against the compilation rather than inferred from the directory + it.dependsOn(tasks.named('compileJava')) + ['compileGroovy', 'copyAstClasses'].each { String name -> + if (project.tasks.findByName(name)) { + it.dependsOn(tasks.named(name)) + } } + it.classesDirs.from(classesDirs) + it.templateClasspath.from(project.configurations.named('compileClasspath')) + it.templateOverrides.from( + project.fileTree(project.layout.projectDirectory.dir('src/main/templates/scaffolding')) + .matching { PatternFilterable p -> p.include('*.gsp') }) + it.applicationViews.from( + project.fileTree(appViews) + .matching { PatternFilterable p -> p.include('**/*.gsp') }) + it.outputDirectory.set(project.layout.buildDirectory.dir('generated/scaffolded-views')) } - it.classesDirs.from(classesDirs) - it.templateClasspath.from(project.configurations.named('compileClasspath')) - it.templateOverrides.from( - project.fileTree(project.layout.projectDirectory.dir('src/main/templates/scaffolding')) - .matching { PatternFilterable p -> p.include('*.gsp') }) - it.applicationViews.from( - project.fileTree(project.layout.projectDirectory.dir('grails-app/views')) - .matching { PatternFilterable p -> p.include('**/*.gsp') }) - it.outputDirectory.set(project.layout.buildDirectory.dir('generated/scaffolded-views')) - } - def stageGroovyPages = tasks.register('stageGroovyPages', Sync) { Sync it -> - it.description = 'Collects the application and scaffolded views for GSP compilation' - it.into(stagedViews) - it.from(project.layout.projectDirectory.dir('grails-app/views')) - it.from(generateScaffoldedViews) - // the application's own page wins, matching how the view resolvers are ordered - it.duplicatesStrategy = DuplicatesStrategy.EXCLUDE + tasks.register('stageGroovyPages', Sync) { Sync it -> + it.description = 'Collects the application and scaffolded views for GSP compilation' + it.into(stagedViews) + it.from(appViews) + it.from(generateScaffoldedViews) + // the application's own page wins, matching how the view resolvers are ordered + it.duplicatesStrategy = DuplicatesStrategy.EXCLUDE + } + viewsToCompile = stagedViews.get() } def compileGroovyPages = tasks.register('compileGroovyPages', GroovyPageForkCompileTask) { it.destinationDirectory.set(destDir) it.tmpDirPath = getTmpDirPath(project) - // resolved here because the setter takes a directory, not a provider: it has to set - // both srcDir and the SourceTask inputs, and setting srcDir alone compiles nothing - it.source = stagedViews.get() + // the setter takes a directory rather than a provider: it has to set both srcDir + // and the SourceTask inputs, and setting srcDir alone compiles nothing + it.source = viewsToCompile it.serverpath.set('/WEB-INF/grails-app/views/') it.classpath = allClasspath - it.dependsOn(stageGroovyPages) + if (scaffolds) { + it.dependsOn(tasks.named('stageGroovyPages')) + } } def compileWebappGroovyPages = tasks.register('compileWebappGroovyPages', GroovyPageForkCompileTask) { @@ -177,6 +189,25 @@ class GroovyPagePlugin implements Plugin { } } + /** + * Whether any controller in this project is scaffolded, read from the sources because the + * decision is needed before anything is compiled. A project that does not scaffold compiles its + * views where they are, as it did before. + */ + protected boolean scaffoldsAnyController(Project project) { + File controllers = project.layout.projectDirectory.dir('grails-app/controllers').asFile + if (!controllers.isDirectory()) { + return false + } + boolean found = false + controllers.eachFileRecurse { File file -> + if (!found && file.name.endsWith('.groovy') && file.text.contains('@Scaffold')) { + found = true + } + } + found + } + protected FileCollection resolveClassesDirs(SourceSetOutput output, Project project) { output?.classesDirs ?: project.files(project.layout.buildDirectory.dir('classes/main')) } From b1611e36abb51bc03c9ebf152c9d8fd3b0350159 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 15:16:31 -0700 Subject: [PATCH 020/115] Carry a bean's injection into the code generated for it Generating a context ahead of time normally makes the injection annotations unnecessary: the generator reads them and writes the field and method access into the code it emits. Two kinds of injection did not survive that, and neither failed at start-up -- the first request that reached the bean did. A bean's autowire mode was not written out at all. Grails registers much of what it contributes as autowired by name, so a tag library arrived holding null where it expected a message source. The mode is now carried into the generated definition, for whatever set it. An annotated member is only generated for when the generator can see the class declaring it. A bean contributed as an interface built by a supplier hides that class -- the link generator is declared as LinkGenerator and built by a closure -- so its annotated field was injected by nobody. The two processors that read those annotations are registered when running on generated artifacts. Only those two: registering the whole set brings back the processor that reads configuration classes, and reading them again in a context whose configuration is already generated makes a second definition for beans the generated code has contributed, which fails the context outright. (cherry picked from commit dbe0b2f9ff1f205266e0f1b2c9202baf708ad616) --- .../GrailsApplicationPostProcessor.groovy | 48 +++++++++ ...owireModeBeanRegistrationAotProcessor.java | 91 +++++++++++++++++ .../resources/META-INF/spring/aot.factories | 3 + ...onPostProcessorAnnotationConfigSpec.groovy | 98 +++++++++++++++++++ ...odeBeanRegistrationAotProcessorSpec.groovy | 70 +++++++++++++ 5 files changed, 310 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java create mode 100644 grails-core/src/test/groovy/grails/boot/config/GrailsApplicationPostProcessorAnnotationConfigSpec.groovy create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy b/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy index 297ae6046fd..cbdbd415f45 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy @@ -29,6 +29,12 @@ import org.springframework.beans.factory.config.ConfigurableBeanFactory import org.springframework.beans.factory.config.ConfigurableListableBeanFactory import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor +import org.springframework.context.annotation.AnnotationConfigUtils +import org.springframework.aot.AotDetector +import org.springframework.beans.factory.support.RootBeanDefinition +import org.springframework.beans.factory.config.BeanDefinition +import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor +import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor import org.springframework.beans.factory.support.BeanRegistryAdapter import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationContextAware @@ -238,6 +244,8 @@ class GrailsApplicationPostProcessor implements BeanDefinitionRegistryPostProces @Override void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { + registerAnnotationConfigProcessorsForGeneratedArtifacts(registry) + def springConfig = new DefaultRuntimeSpringConfiguration() def application = grailsApplication Holders.setGrailsApplication(application) @@ -322,6 +330,46 @@ class GrailsApplicationPostProcessor implements BeanDefinitionRegistryPostProces } } + /** + * Restores the processors that read the injection annotations, when running on artifacts + * generated ahead of time. + * + *

    Generating those artifacts normally makes these unnecessary: the generator reads the + * annotations itself and writes the field and method access into the code it emits, which is why + * a controller or a tag library arrives fully injected without them. It can only do that for a + * bean whose implementation it can see, and a bean contributed as an interface built by a + * supplier hides it -- the link generator is declared as {@code LinkGenerator} and built by a + * closure, so the {@code @Autowired} field on the implementation is generated for by nobody. + * Nothing fails at start-up; the first page that follows a link does.

    + * + *

    Only the two that inject are restored. Registering the whole set would bring back the + * processor that reads configuration classes, and reading them again in a context whose + * configuration has already been generated makes a second definition for beans the generated + * code has already contributed.

    + * + *

    They are registered under the names Spring uses itself, so a context that already has them + * keeps what it has, and a context running without generated artifacts is untouched.

    + */ + protected static void registerAnnotationConfigProcessorsForGeneratedArtifacts(BeanDefinitionRegistry registry) { + if (!AotDetector.useGeneratedArtifacts()) { + return + } + registerInfrastructureBean(registry, AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME, + AutowiredAnnotationBeanPostProcessor) + registerInfrastructureBean(registry, AnnotationConfigUtils.COMMON_ANNOTATION_PROCESSOR_BEAN_NAME, + CommonAnnotationBeanPostProcessor) + } + + private static void registerInfrastructureBean(BeanDefinitionRegistry registry, String beanName, + Class beanClass) { + if (registry.containsBeanDefinition(beanName)) { + return + } + RootBeanDefinition definition = new RootBeanDefinition(beanClass) + definition.role = BeanDefinition.ROLE_INFRASTRUCTURE + registry.registerBeanDefinition(beanName, definition) + } + @Override void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { BeanFactory parentBeanFactory = beanFactory.getParentBeanFactory() diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java new file mode 100644 index 00000000000..a530e5e9f93 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java @@ -0,0 +1,91 @@ +/* + * 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.grails.spring.beans.aot; + +import java.util.function.Predicate; + +import org.springframework.aot.generate.GenerationContext; +import org.springframework.beans.factory.aot.BeanRegistrationAotContribution; +import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor; +import org.springframework.beans.factory.aot.BeanRegistrationCode; +import org.springframework.beans.factory.aot.BeanRegistrationCodeFragments; +import org.springframework.beans.factory.aot.BeanRegistrationCodeFragmentsDecorator; +import org.springframework.beans.factory.support.AbstractBeanDefinition; +import org.springframework.beans.factory.support.RegisteredBean; +import org.springframework.beans.factory.support.RootBeanDefinition; +import org.springframework.javapoet.CodeBlock; +import org.springframework.lang.Nullable; + +/** + * Carries a bean's autowire mode into the code generated for it ahead of time. + * + *

    Grails registers much of what it contributes as autowired by name: a tag library, a controller + * or an interceptor takes its collaborators from beans of the same name, without annotating them. + * The generator writes out most of a definition but not this, so a bean rebuilt from generated code + * arrives with those collaborators unset -- a tag library holding null where it expects a message + * source, and a link generator holding null where it expects the URL mappings. Nothing fails at + * start-up; the first page that reaches one of them does.

    + * + *

    The annotated injection is unaffected either way, because the generator resolves that itself + * and writes the field and method access into the instance supplier. This only restores what + * convention supplies.

    + * + * @since 8.0 + */ +public class AutowireModeBeanRegistrationAotProcessor implements BeanRegistrationAotProcessor { + + @Override + @Nullable + public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) { + int autowireMode = autowireModeOf(registeredBean); + if (autowireMode == AbstractBeanDefinition.AUTOWIRE_NO) { + return null; + } + return BeanRegistrationAotContribution.withCustomCodeFragments( + codeFragments -> new AutowireModeCodeFragments(codeFragments, autowireMode)); + } + + private int autowireModeOf(RegisteredBean registeredBean) { + RootBeanDefinition definition = registeredBean.getMergedBeanDefinition(); + return definition.getAutowireMode(); + } + + /** Appends the assignment the generator leaves out to the properties it does write. */ + private static final class AutowireModeCodeFragments extends BeanRegistrationCodeFragmentsDecorator { + + private final int autowireMode; + + private AutowireModeCodeFragments(BeanRegistrationCodeFragments delegate, int autowireMode) { + super(delegate); + this.autowireMode = autowireMode; + } + + @Override + public CodeBlock generateSetBeanDefinitionPropertiesCode(GenerationContext generationContext, + BeanRegistrationCode beanRegistrationCode, RootBeanDefinition beanDefinition, + Predicate attributeFilter) { + CodeBlock properties = super.generateSetBeanDefinitionPropertiesCode(generationContext, + beanRegistrationCode, beanDefinition, attributeFilter); + return CodeBlock.builder() + .add(properties) + .addStatement("$L.setAutowireMode($L)", BEAN_DEFINITION_VARIABLE, this.autowireMode) + .build(); + } + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index 3a2f1229ece..5f33034830e 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -3,3 +3,6 @@ org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter org.springframework.aot.hint.RuntimeHintsRegistrar=\ org.grails.spring.beans.aot.GrailsClosureRuntimeHints + +org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ +org.grails.spring.beans.aot.AutowireModeBeanRegistrationAotProcessor diff --git a/grails-core/src/test/groovy/grails/boot/config/GrailsApplicationPostProcessorAnnotationConfigSpec.groovy b/grails-core/src/test/groovy/grails/boot/config/GrailsApplicationPostProcessorAnnotationConfigSpec.groovy new file mode 100644 index 00000000000..7789f062c17 --- /dev/null +++ b/grails-core/src/test/groovy/grails/boot/config/GrailsApplicationPostProcessorAnnotationConfigSpec.groovy @@ -0,0 +1,98 @@ +/* + * 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 grails.boot.config + +import org.springframework.aot.AotDetector +import org.springframework.beans.factory.support.BeanDefinitionRegistry +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.beans.factory.support.RootBeanDefinition +import org.springframework.context.annotation.AnnotationConfigUtils +import spock.lang.Specification + +/** + * Covers the processors that read the injection annotations being restored when running on + * artifacts generated ahead of time. + * + *

    The generator resolves the annotations itself for a bean whose implementation it can see, but a + * bean contributed as an interface built by a supplier hides that implementation, and the annotated + * members on it are then injected by nobody.

    + */ +class GrailsApplicationPostProcessorAnnotationConfigSpec extends Specification { + + private static final String AOT_KEY = 'spring.aot.enabled' + + BeanDefinitionRegistry registry = new DefaultListableBeanFactory() + + /** Restores the property, so the environment other specs observe is unchanged. */ + private void withGeneratedArtifacts(boolean enabled, Closure body) { + String previous = System.getProperty(AOT_KEY) + try { + enabled ? System.setProperty(AOT_KEY, 'true') : System.clearProperty(AOT_KEY) + body.call() + } + finally { + previous == null ? System.clearProperty(AOT_KEY) : System.setProperty(AOT_KEY, previous) + } + } + + private void register() { + GrailsApplicationPostProcessor.registerAnnotationConfigProcessorsForGeneratedArtifacts(registry) + } + + void 'the injection processors are registered when running on generated artifacts'() { + when: + withGeneratedArtifacts(true) { register() } + + then: + registry.containsBeanDefinition(AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME) + registry.containsBeanDefinition(AnnotationConfigUtils.COMMON_ANNOTATION_PROCESSOR_BEAN_NAME) + } + + void 'the processor that reads configuration classes is not'() { + when: + withGeneratedArtifacts(true) { register() } + + then: 'reading them again in a context whose configuration is already generated makes a ' + + 'second definition for beans the generated code has contributed' + !registry.containsBeanDefinition(AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME) + } + + void 'nothing is registered without generated artifacts'() { + when: + withGeneratedArtifacts(false) { register() } + + then: + !registry.containsBeanDefinition(AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME) + !registry.containsBeanDefinition(AnnotationConfigUtils.COMMON_ANNOTATION_PROCESSOR_BEAN_NAME) + } + + void 'a context that already has them keeps what it has'() { + given: + RootBeanDefinition existing = new RootBeanDefinition(String) + registry.registerBeanDefinition( + AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME, existing) + + when: + withGeneratedArtifacts(true) { register() } + + then: + registry.getBeanDefinition( + AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME).is(existing) + } +} diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy new file mode 100644 index 00000000000..f08b4db347d --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy @@ -0,0 +1,70 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.beans.factory.support.AbstractBeanDefinition +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.beans.factory.support.RegisteredBean +import org.springframework.beans.factory.support.RootBeanDefinition +import spock.lang.Specification + +/** + * Covers a bean's autowire mode reaching the code generated for it. + * + *

    Grails registers much of what it contributes as autowired by name, and the generator writes out + * most of a definition but not that, so a bean rebuilt from generated code would arrive with those + * collaborators unset. Nothing fails at start-up; the first request that reaches one does.

    + */ +class AutowireModeBeanRegistrationAotProcessorSpec extends Specification { + + DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory() + + AutowireModeBeanRegistrationAotProcessor processor = new AutowireModeBeanRegistrationAotProcessor() + + private RegisteredBean register(String name, int autowireMode) { + RootBeanDefinition definition = new RootBeanDefinition(Collaborating) + definition.autowireMode = autowireMode + beanFactory.registerBeanDefinition(name, definition) + RegisteredBean.of(beanFactory, name) + } + + void 'a bean autowired by name is contributed to'() { + expect: + processor.processAheadOfTime(register('byName', AbstractBeanDefinition.AUTOWIRE_BY_NAME)) != null + } + + void 'a bean autowired by type is contributed to'() { + expect: + processor.processAheadOfTime(register('byType', AbstractBeanDefinition.AUTOWIRE_BY_TYPE)) != null + } + + void 'a bean that is not autowired is left alone'() { + expect: 'contributing to every bean would put a redundant assignment in every definition' + processor.processAheadOfTime(register('plain', AbstractBeanDefinition.AUTOWIRE_NO)) == null + } + + static class Collaborating { + + String collaborator + + void setCollaborator(String collaborator) { + this.collaborator = collaborator + } + } +} From 3e0a6fe23e21204df32d286becfbbc19610ada48 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 15:19:19 -0700 Subject: [PATCH 021/115] Contribute tag library definitions without replacing what is registered The GSP plugin registered a bean for every tag library from doWithSpring(), which meant registering them again on every start, over whatever was already there. On a running JVM that only made noise. On a context generated ahead of time it replaced definitions that carried the injection the generator had worked out, leaving a tag library holding null where it expected a collaborator, and by-name autowiring did not stand in for it because those collaborators are fields. The definitions are contributed by a post-processor instead, which leaves an existing definition alone. The artefacts are read from the application rather than named, so a tag library still belongs to whoever declared it: the application, another plugin, or one supplied through providedArtefacts. Where a definition is already there but has lost its autowire mode, the mode is raised back to by-name and never lowered, so a definition asking for something else keeps it. (cherry picked from commit 03c353953382fbf50a7924dcb5151f9618bb2591) --- .../web/GroovyPagesGrailsPlugin.groovy | 33 +++-- .../TagLibBeanDefinitionsPostProcessor.groovy | 115 +++++++++++++++++ ...LibBeanDefinitionsPostProcessorSpec.groovy | 116 ++++++++++++++++++ 3 files changed, 251 insertions(+), 13 deletions(-) create mode 100644 grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy create mode 100644 grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index f53d4ffeb32..b711c424344 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -22,6 +22,8 @@ import groovy.transform.CompileStatic import groovy.util.logging.Slf4j import org.springframework.aot.AotDetector +import org.springframework.beans.factory.BeanRegistry +import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.config.PropertiesFactoryBean import org.springframework.boot.web.servlet.ServletRegistrationBean import org.springframework.core.io.Resource @@ -104,6 +106,24 @@ class GroovyPagesGrailsPlugin extends Plugin { applicationContext.getBean('groovyPagesTemplateEngine', GroovyPagesTemplateEngine).clearPageCache() } + /** + * Tag library beans autowire by name and are read from the artefacts the application knows + * about, which the {@link org.springframework.beans.factory.BeanRegistry} API cannot express, so + * their definitions are contributed by a dedicated post-processor. Contributing them here rather + * than from {@code doWithSpring()} leaves the definitions an ahead-of-time image generated, and + * the injection generated with them, in place. + */ + @Override + BeanRegistrar beanRegistrar() { + { BeanRegistry registry, org.springframework.core.env.Environment environment -> + registry.registerBean('tagLibBeanDefinitionsPostProcessor', TagLibBeanDefinitionsPostProcessor) { + it.infrastructure().supplier { + new TagLibBeanDefinitionsPostProcessor(grailsApplication) + } + } + } as BeanRegistrar + } + /** * Configures the various Spring beans required by GSP */ @@ -256,19 +276,6 @@ class GroovyPagesGrailsPlugin extends Plugin { // Configure a Spring MVC view resolver if none is defined groovyPagesPostProcessor(GroovyPagesPostProcessor) - // Now go through tag libraries and configure them in Spring too. With AOP proxies and so on - for (taglib in application.tagLibClasses) { - - final tagLibClass = taglib.clazz - - "${taglib.fullName}"(tagLibClass) { bean -> - bean.autowire = true - bean.lazyInit = true - - // Taglib scoping support could be easily added here. Scope could be based on a static field in the taglib class. - //bean.scope = 'request' - } - } errorsViewStackTracePrinter(ErrorsViewStackTracePrinter, ref('grailsResourceLocator')) filteringCodecsByContentTypeSettings(FilteringCodecsByContentTypeSettings, ref('grailsApplication')) diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy new file mode 100644 index 00000000000..7c7f3268c0e --- /dev/null +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy @@ -0,0 +1,115 @@ +/* + * 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.grails.plugins.web + +import groovy.transform.CompileStatic +import groovy.util.logging.Slf4j + +import org.springframework.beans.factory.config.BeanDefinition +import org.springframework.beans.factory.config.ConfigurableListableBeanFactory +import org.springframework.beans.factory.support.AbstractBeanDefinition +import org.springframework.beans.factory.support.BeanDefinitionRegistry +import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor +import org.springframework.beans.factory.support.GenericBeanDefinition +import org.springframework.core.PriorityOrdered + +import grails.core.GrailsApplication +import grails.core.gsp.GrailsTagLibClass +import org.grails.core.artefact.gsp.TagLibArtefactHandler + +/** + * Registers a bean definition for every tag library artefact, replacing the registration the GSP + * plugin previously performed through the {@code doWithSpring()} bean DSL. + * + *

    Registering them there meant registering them again on every start, over whatever was already + * there. That is harmless on a running JVM, but an ahead-of-time image has already generated a + * definition for each tag library, carrying the field and method injection the generator worked out + * at build time. Replacing it discarded that injection, leaving a tag library holding null where it + * expected a collaborator -- and by-name autowiring did not stand in for it, because the + * collaborators are fields rather than properties. Contributing the definitions from here leaves the + * generated ones alone.

    + * + *

    The artefacts are read from the application rather than named individually, so a tag library + * belongs to whoever declared it: the application, another plugin, or one supplied through + * {@code providedArtefacts}. An existing definition for the same name wins, which preserves the + * ability to override a tag library.

    + * + * @since 8.0 + */ +@Slf4j +@CompileStatic +class TagLibBeanDefinitionsPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered { + + private final GrailsApplication grailsApplication + + TagLibBeanDefinitionsPostProcessor(GrailsApplication grailsApplication) { + this.grailsApplication = grailsApplication + } + + @Override + void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { + for (Object each : grailsApplication.getArtefacts(TagLibArtefactHandler.TYPE)) { + GrailsTagLibClass artefact = (GrailsTagLibClass) each + String beanName = artefact.fullName + if (!artefact.available) { + continue + } + if (registry.containsBeanDefinition(beanName)) { + restoreAutowiringByName(registry.getBeanDefinition(beanName), beanName) + continue + } + GenericBeanDefinition definition = new GenericBeanDefinition( + beanClass: artefact.clazz, + lazyInit: true, + autowireMode: AbstractBeanDefinition.AUTOWIRE_BY_NAME + ) + registry.registerBeanDefinition(beanName, definition) + log.debug('Registered tag library {}', beanName) + } + } + + /** + * Restores by-name autowiring on a definition that already exists. + * + *

    A tag library takes some of its collaborators by name rather than by annotation, and + * ahead-of-time processing does not carry that over: it generates the injection it can see from + * the annotations and leaves the mode at none, so a message source or an asset resolver arrives + * null. The mode is only ever raised, never lowered, so a definition that asks for something + * else keeps it.

    + */ + private void restoreAutowiringByName(BeanDefinition existing, String beanName) { + if (!(existing instanceof AbstractBeanDefinition)) { + return + } + AbstractBeanDefinition definition = (AbstractBeanDefinition) existing + if (definition.autowireMode == AbstractBeanDefinition.AUTOWIRE_NO) { + definition.autowireMode = AbstractBeanDefinition.AUTOWIRE_BY_NAME + log.debug('Restored autowiring by name on tag library {}', beanName) + } + } + + @Override + void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { + } + + @Override + int getOrder() { + HIGHEST_PRECEDENCE + } +} diff --git a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy new file mode 100644 index 00000000000..ff1d63b8d07 --- /dev/null +++ b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy @@ -0,0 +1,116 @@ +/* + * 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.grails.plugins.web + +import grails.core.DefaultGrailsApplication +import grails.core.GrailsApplication + +import org.springframework.beans.factory.support.AbstractBeanDefinition +import org.springframework.beans.factory.support.BeanDefinitionRegistry +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.beans.factory.support.RootBeanDefinition +import spock.lang.Specification + +/** + * Covers tag library definitions being contributed without replacing what is already registered. + * + *

    The GSP plugin used to register them from {@code doWithSpring()}, over whatever was there. An + * ahead-of-time image has already generated a definition for each one, carrying the injection the + * generator worked out, and replacing it discarded that.

    + */ +class TagLibBeanDefinitionsPostProcessorSpec extends Specification { + + BeanDefinitionRegistry registry = new DefaultListableBeanFactory() + + GrailsApplication grailsApplication + + void setup() { + grailsApplication = new DefaultGrailsApplication(DemoTagLib) + grailsApplication.initialise() + } + + private void process() { + new TagLibBeanDefinitionsPostProcessor(grailsApplication).postProcessBeanDefinitionRegistry(registry) + } + + void 'a tag library the application knows about is registered'() { + when: + process() + + then: + registry.containsBeanDefinition(DemoTagLib.name) + } + + void 'the definition is lazy and autowired by name'() { + when: + process() + AbstractBeanDefinition definition = + (AbstractBeanDefinition) registry.getBeanDefinition(DemoTagLib.name) + + then: 'a tag library takes some collaborators by name rather than by annotation' + definition.lazyInit + definition.autowireMode == AbstractBeanDefinition.AUTOWIRE_BY_NAME + } + + void 'a definition that is already registered is kept'() { + given: 'the definition an ahead-of-time image generated, carrying its own injection' + RootBeanDefinition generated = new RootBeanDefinition(DemoTagLib) + registry.registerBeanDefinition(DemoTagLib.name, generated) + + when: + process() + + then: + registry.getBeanDefinition(DemoTagLib.name).is(generated) + } + + void 'autowiring by name is restored on a definition that lost it'() { + given: 'the generator does not write the mode out, so it arrives as none' + RootBeanDefinition generated = new RootBeanDefinition(DemoTagLib) + generated.autowireMode = AbstractBeanDefinition.AUTOWIRE_NO + registry.registerBeanDefinition(DemoTagLib.name, generated) + + when: + process() + + then: + generated.autowireMode == AbstractBeanDefinition.AUTOWIRE_BY_NAME + } + + void 'a definition asking for something else keeps it'() { + given: + RootBeanDefinition generated = new RootBeanDefinition(DemoTagLib) + generated.autowireMode = AbstractBeanDefinition.AUTOWIRE_BY_TYPE + registry.registerBeanDefinition(DemoTagLib.name, generated) + + when: + process() + + then: 'the mode is only ever raised, never lowered' + generated.autowireMode == AbstractBeanDefinition.AUTOWIRE_BY_TYPE + } + + /** Recognised as a tag library by its name, which is what the artefact handler reads. */ + static class DemoTagLib { + + static namespace = 'demo' + + Closure hello = { attrs -> } + } +} From 2885d88f7212a825ea0a5814a7d5357c9a3f0e4e Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 16:22:38 -0700 Subject: [PATCH 022/115] Gather a variable-argument constructor argument into the array it feeds A bean declared through the plugin DSL passes its arguments positionally, and a constructor ending in a variable-argument parameter is called the way the language allows: one value where the parameter is an array, or a collection where it is an array of that element type. Building the bean, Spring adapts the argument to the parameter. Reading the definition to generate code for it, Spring does not -- it looks the argument up by the parameter's type, and a lone String does not answer to String[]. The argument is then missed and resolved as a dependency instead, and an array of a type nobody publishes as a bean resolves to an empty array rather than failing. So the bean is built, and built wrong: a datastore that maps no classes, or a servlet registration with no URL mapping, which then falls back to mapping everything and swallows every request. Nothing is logged, and the bean that goes wrong is rarely the one that reports it. Gathering the argument ahead of time means the generator writes out new String[] {"*.gsp"}, which the lookup does find. An argument already usable as the array is left alone, and one whose elements would need converting is left to the resolution that exists today rather than guessed at here. The tests read the code that is actually generated, because the failure this guards against is one where every bean is still registered and still built. (cherry picked from commit b91d09ee1c3b8dcd1ef97e9b025c642705f13366) --- .../VarargsBeanRegistrationAotProcessor.java | 179 ++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 3 +- ...rgsBeanRegistrationAotProcessorSpec.groovy | 149 +++++++++++++++ 3 files changed, 330 insertions(+), 1 deletion(-) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java new file mode 100644 index 00000000000..35ff32e3813 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java @@ -0,0 +1,179 @@ +/* + * 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.grails.spring.beans.aot; + +import java.lang.reflect.Array; +import java.lang.reflect.Executable; +import java.util.Collection; +import java.util.List; +import java.util.function.Predicate; + +import org.springframework.aot.generate.GenerationContext; +import org.springframework.beans.factory.aot.BeanRegistrationAotContribution; +import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor; +import org.springframework.beans.factory.aot.BeanRegistrationCode; +import org.springframework.beans.factory.aot.BeanRegistrationCodeFragments; +import org.springframework.beans.factory.aot.BeanRegistrationCodeFragmentsDecorator; +import org.springframework.beans.factory.config.ConstructorArgumentValues; +import org.springframework.beans.factory.config.ConstructorArgumentValues.ValueHolder; +import org.springframework.beans.factory.support.RegisteredBean; +import org.springframework.beans.factory.support.RootBeanDefinition; +import org.springframework.javapoet.CodeBlock; +import org.springframework.lang.Nullable; +import org.springframework.util.ClassUtils; + +/** + * Gathers a variable-argument constructor argument into the array it feeds, ahead of time. + * + *

    A bean declared through the plugin DSL passes its arguments positionally, and a constructor + * that ends in a variable-argument parameter is called the way the language allows: one value where + * the parameter is an array, or a collection where it is an array of that element type. Building the + * bean, Spring adapts the argument to the parameter. Reading the definition to generate code for it, + * Spring does not: it looks the argument up by the parameter's type, and a lone {@code String} does + * not answer to {@code String[]}.

    + * + *

    The argument is then missed and resolved as a dependency instead, and an array of a type nobody + * publishes as a bean resolves to an empty array rather than failing. So the bean is built, and + * built wrong: a datastore that maps no classes, or a servlet registration with no URL mapping, + * which then falls back to mapping everything. Nothing is logged, and the bean that goes wrong is + * rarely the one that reports it -- the first symptom is a page that 404s or a domain class that + * says it is not one.

    + * + *

    Gathering the argument into an array here means the generator writes out {@code new String[] + * {"*.gsp"}}, which the lookup does find. Only an argument that is already usable as the array is + * left alone, and an argument that would need its elements converted is left to the resolution that + * exists today rather than guessed at here.

    + * + * @since 8.0 + */ +public class VarargsBeanRegistrationAotProcessor implements BeanRegistrationAotProcessor { + + @Override + @Nullable + public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) { + Executable executable = resolveExecutable(registeredBean); + if (executable == null || !executable.isVarArgs()) { + return null; + } + Class[] parameterTypes = executable.getParameterTypes(); + RootBeanDefinition beanDefinition = registeredBean.getMergedBeanDefinition(); + Object gathered = gatherTrailingArgument(beanDefinition.getConstructorArgumentValues(), parameterTypes); + if (gathered == null) { + return null; + } + return BeanRegistrationAotContribution.withCustomCodeFragments( + codeFragments -> new VarargsCodeFragments(codeFragments, gathered)); + } + + /** + * The constructor or factory method the generator will write the call to. + * + *

    Resolution reads the bean class and its members, so a bean whose class cannot be resolved + * fails here rather than at the point of use. It is not this processor's place to report that: + * generation carries on and fails where it means something.

    + */ + @Nullable + private Executable resolveExecutable(RegisteredBean registeredBean) { + try { + return registeredBean.resolveConstructorOrFactoryMethod(); + } + catch (Throwable ignored) { + return null; + } + } + + /** + * The trailing argument as the array its parameter takes, or {@code null} to leave it alone. + * + *

    Only the straightforward reading is handled: one argument per parameter, the last of them + * standing for the variable-argument array. An argument list that spreads several values across + * that parameter, or that is indexed rather than positional, is left as it is.

    + */ + @Nullable + private Object gatherTrailingArgument(ConstructorArgumentValues arguments, Class[] parameterTypes) { + if (!arguments.getIndexedArgumentValues().isEmpty()) { + return null; + } + List supplied = arguments.getGenericArgumentValues(); + if (supplied.size() != parameterTypes.length) { + return null; + } + Class arrayType = parameterTypes[parameterTypes.length - 1]; + if (!arrayType.isArray()) { + return null; + } + Object value = supplied.get(supplied.size() - 1).getValue(); + if (value == null || ClassUtils.isAssignableValue(arrayType, value)) { + return null; + } + Class componentType = arrayType.getComponentType(); + Collection elements = value instanceof Collection collection ? collection : List.of(value); + return toArray(elements, componentType); + } + + /** + * The elements as an array of the component type, or {@code null} if any of them is not already + * one. Converting an element is the resolution step's job, and guessing at it here would turn a + * missed argument into a wrong one. + */ + @Nullable + private Object toArray(Collection elements, Class componentType) { + for (Object element : elements) { + if (element == null || !ClassUtils.isAssignableValue(componentType, element)) { + return null; + } + } + Object array = Array.newInstance(componentType, elements.size()); + int index = 0; + for (Object element : elements) { + Array.set(array, index++, element); + } + return array; + } + + /** Writes the definition out with the gathered argument in place of the one supplied. */ + private static final class VarargsCodeFragments extends BeanRegistrationCodeFragmentsDecorator { + + private final Object gathered; + + private VarargsCodeFragments(BeanRegistrationCodeFragments delegate, Object gathered) { + super(delegate); + this.gathered = gathered; + } + + @Override + public CodeBlock generateSetBeanDefinitionPropertiesCode(GenerationContext generationContext, + BeanRegistrationCode beanRegistrationCode, RootBeanDefinition beanDefinition, + Predicate attributeFilter) { + return super.generateSetBeanDefinitionPropertiesCode(generationContext, beanRegistrationCode, + withGatheredArgument(beanDefinition), attributeFilter); + } + + /** + * A copy carrying the gathered argument, so the definition the context is running on keeps + * the argument it was given and only the generated code differs. + */ + private RootBeanDefinition withGatheredArgument(RootBeanDefinition beanDefinition) { + RootBeanDefinition copy = new RootBeanDefinition(beanDefinition); + List supplied = copy.getConstructorArgumentValues().getGenericArgumentValues(); + supplied.get(supplied.size() - 1).setValue(this.gathered); + return copy; + } + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index 5f33034830e..88fbea2056b 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -5,4 +5,5 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ org.grails.spring.beans.aot.GrailsClosureRuntimeHints org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ -org.grails.spring.beans.aot.AutowireModeBeanRegistrationAotProcessor +org.grails.spring.beans.aot.AutowireModeBeanRegistrationAotProcessor,\ +org.grails.spring.beans.aot.VarargsBeanRegistrationAotProcessor diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy new file mode 100644 index 00000000000..0e544488dc6 --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy @@ -0,0 +1,149 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.aot.generate.ClassNameGenerator +import org.springframework.aot.generate.DefaultGenerationContext +import org.springframework.aot.generate.GeneratedFiles +import org.springframework.aot.generate.InMemoryGeneratedFiles +import org.springframework.beans.factory.config.RuntimeBeanReference +import org.springframework.beans.factory.support.RootBeanDefinition +import org.springframework.context.aot.ApplicationContextAotGenerator +import org.springframework.context.support.GenericApplicationContext +import org.springframework.javapoet.ClassName +import spock.lang.Specification + +/** + * Covers a variable-argument constructor argument being gathered into the array it feeds. + * + *

    Spring adapts the argument when it builds the bean, but not when it reads the definition to + * generate code for it: it looks the argument up by the parameter's type, misses a value that is not + * already the array, and resolves it as a dependency instead -- which for an array type is an empty + * array. The bean is then built with nothing where its arguments should be, and says so much later.

    + * + *

    These read the code that is actually generated, because the failure this guards against is one + * where every bean is still registered and still built.

    + */ +class VarargsBeanRegistrationAotProcessorSpec extends Specification { + + GenericApplicationContext context = new GenericApplicationContext() + + void cleanup() { + context.close() + } + + /** The generated source for a context holding one bean with the given constructor arguments. */ + private String generatedSourceFor(Class beanClass, List arguments) { + RootBeanDefinition definition = new RootBeanDefinition(beanClass) + arguments.each { definition.constructorArgumentValues.addGenericArgumentValue(it) } + context.registerBeanDefinition('subject', definition) + + InMemoryGeneratedFiles generatedFiles = new InMemoryGeneratedFiles() + DefaultGenerationContext generationContext = new DefaultGenerationContext( + new ClassNameGenerator(ClassName.get('com.example', 'Subject')), generatedFiles) + new ApplicationContextAotGenerator().processAheadOfTime(context, generationContext) + generationContext.writeGeneratedContent() + + generatedFiles.getGeneratedFiles(GeneratedFiles.Kind.SOURCE) + .keySet() + .collect { generatedFiles.getGeneratedFileContent(GeneratedFiles.Kind.SOURCE, it) } + .join('\n') + } + + void 'a lone value is gathered into the array its parameter takes'() { + when: + String generated = generatedSourceFor(Registration, ['*.gsp']) + + then: 'a bare "*.gsp" does not answer to String[], so the generated lookup would miss it' + generated.contains('new String[] {"*.gsp"}') + } + + void 'a collection is gathered into the array of its element type'() { + when: + String generated = generatedSourceFor(Mapped, [[String, Integer]]) + + then: + generated.contains('new Class[] {String.class, Integer.class}') + } + + void 'an argument that is already the array is left as it is'() { + when: + String generated = generatedSourceFor(Registration, [['*.gsp', '*.jsp'] as String[]]) + + then: + generated.contains('new String[] {"*.gsp", "*.jsp"}') + } + + void 'a fixed constructor is untouched'() { + when: + String generated = generatedSourceFor(Fixed, ['one', 'two']) + + then: + generated.contains('addGenericArgumentValue("one")') + generated.contains('addGenericArgumentValue("two")') + !generated.contains('new String[]') + } + + void 'a reference is left for the context to resolve'() { + given: + context.registerBeanDefinition('elsewhere', new RootBeanDefinition(String)) + + when: + String generated = generatedSourceFor(Registration, [new RuntimeBeanReference('elsewhere')]) + + then: 'what it refers to is not known until the context runs, so it cannot be gathered here' + generated.contains('RuntimeBeanReference("elsewhere")') + !generated.contains('new String[]') + } + + void 'an argument whose elements would need converting is left alone'() { + when: 'a String where the array takes Class' + String generated = generatedSourceFor(Mapped, ['java.lang.String']) + + then: 'gathering it would turn an argument that is missed into one that is wrong' + generated.contains('addGenericArgumentValue("java.lang.String")') + !generated.contains('new Class[]') + } + + void 'a bean built with no arguments is untouched'() { + when: + String generated = generatedSourceFor(Registration, []) + + then: + !generated.contains('new String[]') + } + + static class Registration { + + Registration(String... urlMappings) { + } + } + + static class Mapped { + + Mapped(Class... classes) { + } + } + + static class Fixed { + + Fixed(String one, String two) { + } + } +} From 36d20d11274130a5a750ec2a8c7bbe305710c6ce Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 16:22:55 -0700 Subject: [PATCH 023/115] Leave a datastore's configuration to be read where the application runs A datastore was given the configuration object itself to hold, and a definition holding a property resolver is a definition holding everything that resolver can reach. Generating code for it wrote those values out: the environment of whatever machine ran the build, 223 entries of it in the case at hand, credentials among them, committed into generated source. Worse, the application then read its settings from there rather than from where it runs, so a value that is meant to differ between build and run -- a host, a port, a password -- did not. While code is being generated, and only then, the context's environment is named instead, so the lookup is made where the application runs. Every other time the resolver is held as it always was, which matters for a datastore brought up on its own: its configuration is whatever the caller passed, and there is no environment holding it. The classes a datastore maps are also collected as the array its constructor takes, rather than as a collection that only becomes one because Spring adapts it. Verified on an ahead-of-time application: nothing of the build machine appears in the generated sources, and the datastore resolves its address at startup. (cherry picked from commit f437fdec01ccc40da7b6aa0ef787c336039bbd63) --- .../MongoDbDataStoreSpringInitializer.groovy | 10 +++- .../Neo4jDataStoreSpringInitializer.groovy | 3 +- .../AbstractDatastoreInitializer.groovy | 46 +++++++++++++++++-- 3 files changed, 53 insertions(+), 6 deletions(-) diff --git a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy index 48e83448920..f2ecd46356d 100644 --- a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy +++ b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy @@ -99,15 +99,21 @@ class MongoDbDataStoreSpringInitializer extends AbstractDatastoreInitializer { else { grailsDatastoreEventPublisher(DefaultApplicationEventPublisher) } + // The configuration is referenced rather than passed. Passing it puts the resolver + // itself in the definition, and generating code for a definition means writing out + // whatever it holds: an environment carries the machine's own variables, so the + // generated source ends up containing the build machine's environment, and the + // application reads its settings from wherever it was built rather than where it runs. + Object configurationReference = configurationReference(beanDefinitionRegistry) if (mongo == null) { mongoConnectionSourceFactory(MongoConnectionSourceFactory) { bean -> bean.autowire = true } - mongoDatastore(MongoDatastore, configuration, ref('mongoConnectionSourceFactory'), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) + mongoDatastore(MongoDatastore, configurationReference, ref('mongoConnectionSourceFactory'), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) mongo(mongoDatastore: 'getMongoClient') } else { - mongoDatastore(MongoDatastore, mongo, configuration, ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) + mongoDatastore(MongoDatastore, mongo, configurationReference, ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) } mongoMappingContext(mongoDatastore: 'getMappingContext') diff --git a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy index 7221625fe6d..d8552a19400 100644 --- a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy +++ b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy @@ -85,7 +85,8 @@ class Neo4jDataStoreSpringInitializer extends AbstractDatastoreInitializer { neo4jConnectionSourceFactory(Neo4jConnectionSourceFactory) { bean -> bean.autowire = true } - neo4jDatastore(Neo4jDatastore, configuration, ref("neo4jConnectionSourceFactory"), eventPublisher, collectMappedClasses(DATASTORE_TYPE)) + Object configurationReference = configurationReference(beanDefinitionRegistry) + neo4jDatastore(Neo4jDatastore, configurationReference, ref("neo4jConnectionSourceFactory"), eventPublisher, collectMappedClasses(DATASTORE_TYPE)) neo4jMappingContext(neo4jDatastore: "getMappingContext") neo4jTransactionManager(neo4jDatastore: "getTransactionManager") neo4jAutoTimestampEventListener(neo4jDatastore: "getAutoTimestampEventListener") diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy index 510c47dcdfb..977d62336e1 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy @@ -24,14 +24,17 @@ import java.beans.Introspector import groovy.transform.CompileDynamic import groovy.transform.CompileStatic +import org.springframework.beans.factory.config.RuntimeBeanReference import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationEventPublisher import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.MessageSource import org.springframework.context.ResourceLoaderAware +import org.springframework.context.aot.AbstractAotProcessor import org.springframework.context.support.GenericApplicationContext import org.springframework.context.support.StaticMessageSource +import org.springframework.core.SpringProperties import org.springframework.core.env.ConfigurableEnvironment import org.springframework.core.env.PropertyResolver import org.springframework.core.env.StandardEnvironment @@ -77,6 +80,33 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { Collection persistentClasses = [] Collection packages = [] PropertyResolver configuration = new StandardEnvironment() + + /** + * What a bean definition should hold in place of the configuration itself. + * + *

    A definition holding the resolver is a definition holding everything the resolver can + * reach, and generating code for such a definition writes those values out: an environment + * carries the machine's own variables, so the generated source ends up containing the + * environment of whatever machine built it, along with whatever was in it -- credentials among + * them -- and the application then reads its settings from there rather than from where it + * runs.

    + * + *

    So while code is being generated, and only then, the context's environment is named + * instead, which leaves the lookup to be made where the application runs. Every other time the + * resolver is held as it always was, which matters for a datastore brought up on its own: its + * configuration is whatever the caller passed and there is no environment holding it.

    + */ + protected Object configurationReference(BeanDefinitionRegistry registry) { + if (!SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING)) { + return configuration + } + boolean insideContainer = registry instanceof ConfigurableApplicationContext || + resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext + insideContainer + ? new RuntimeBeanReference(ConfigurableApplicationContext.ENVIRONMENT_BEAN_NAME) + : configuration + } + boolean registerApplicationIfNotPresent = true Object originalConfiguration @@ -266,11 +296,21 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { return {} } - protected Collection collectMappedClasses(String datastoreType) { - def classes = !secondaryDatastore ? persistentClasses : persistentClasses.findAll() { Class cls -> + /** + * The classes this datastore maps, as the array its constructor takes. + * + *

    The array type is what makes this survive ahead-of-time processing. A datastore takes its + * classes as a variable-argument parameter, so the constructor argument the generator writes out + * is looked up by that parameter's type when the bean is rebuilt. A collection does not answer to + * {@code Class[]}, so the lookup misses it and the argument is resolved as a dependency instead, + * which for an array type means every {@code Class} bean in the context: none. The datastore is + * then built mapping nothing, and the first call on a domain class reports that it is not one.

    + */ + protected Class[] collectMappedClasses(String datastoreType) { + Collection classes = !secondaryDatastore ? persistentClasses : persistentClasses.findAll() { Class cls -> isMappedClass(datastoreType, cls) } - return classes + return classes as Class[] } protected boolean isMappedClass(String datastoreType, Class cls) { From b70873614e2e67c9ba18180ad49a74af4181532d Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 16:23:08 -0700 Subject: [PATCH 024/115] Keep the bean definitions that were generated ahead of time Running on generated artifacts, the plugins whose doWithSpring() produced these definitions have already run: they ran while the artifacts were being generated, and what they registered was written out as code and registered again from that code, ahead of this phase. Registering over it discarded the instance supplier the generator wrote -- which resolves the constructor, the fields and the injection methods up front -- and replaced it with a definition that has to find all of that by reflection, which is what a generated image does not carry. So the generated definition stands and the one contributed here is dropped. Anything the generator did not produce a definition for is registered as usual, so a bean a plugin contributes conditionally is unaffected, and on a normal start nothing is skipped: a plugin overrides what came before it exactly as it did. This is one guard where the definitions land rather than one at each call site, so it holds for the early registration phase and the post-processor alike. An ahead-of-time application went from 27 overridden definitions to none. The one remaining message is Spring replacing its own import-aware post-processor with an equivalent definition, which comes from two configuration class post-processors each contributing the same registration. grails-spring had no test task wired, having had no tests; it now applies the shared test configuration. (cherry picked from commit f21062e981349f7eb4962fd95b4214f0add5bc47) --- .../web/GroovyPagesGrailsPlugin.groovy | 1 - grails-spring/build.gradle | 1 + .../DefaultRuntimeSpringConfiguration.java | 32 ++++++- ...ltRuntimeSpringConfigurationAotSpec.groovy | 96 +++++++++++++++++++ 4 files changed, 126 insertions(+), 4 deletions(-) create mode 100644 grails-spring/src/test/groovy/org/grails/spring/DefaultRuntimeSpringConfigurationAotSpec.groovy diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index b711c424344..71984c7a799 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -276,7 +276,6 @@ class GroovyPagesGrailsPlugin extends Plugin { // Configure a Spring MVC view resolver if none is defined groovyPagesPostProcessor(GroovyPagesPostProcessor) - errorsViewStackTracePrinter(ErrorsViewStackTracePrinter, ref('grailsResourceLocator')) filteringCodecsByContentTypeSettings(FilteringCodecsByContentTypeSettings, ref('grailsApplication')) diff --git a/grails-spring/build.gradle b/grails-spring/build.gradle index e0aaa04a5bc..0ee57f7d690 100644 --- a/grails-spring/build.gradle +++ b/grails-spring/build.gradle @@ -62,4 +62,5 @@ dependencies { apply { from rootProject.layout.projectDirectory.file('gradle/docs-config.gradle') + from rootProject.layout.projectDirectory.file('gradle/test-config.gradle') } \ No newline at end of file diff --git a/grails-spring/src/main/groovy/org/grails/spring/DefaultRuntimeSpringConfiguration.java b/grails-spring/src/main/groovy/org/grails/spring/DefaultRuntimeSpringConfiguration.java index fa43f506078..0a97b8e452d 100644 --- a/grails-spring/src/main/groovy/org/grails/spring/DefaultRuntimeSpringConfiguration.java +++ b/grails-spring/src/main/groovy/org/grails/spring/DefaultRuntimeSpringConfiguration.java @@ -33,6 +33,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.springframework.aot.AotDetector; import org.springframework.beans.PropertyValue; import org.springframework.beans.factory.ListableBeanFactory; import org.springframework.beans.factory.config.BeanDefinition; @@ -265,11 +266,36 @@ public void registerBeansWithRegistry(BeanDefinitionRegistry registry) { private void registerUnrefreshedBeansWithRegistry(BeanDefinitionRegistry registry) { if (context != null) { for (String beanName : context.getBeanDefinitionNames()) { - registry.registerBeanDefinition(beanName, context.getBeanDefinition(beanName)); + register(registry, beanName, context.getBeanDefinition(beanName)); } } } + /** + * Registers a definition, leaving in place one that was generated ahead of time. + * + *

    Running on generated artifacts, the plugins that produced these definitions already ran: + * they ran while the artifacts were being generated, and what they registered was written out as + * code and registered again here, ahead of this phase. Registering over that discards the + * instance supplier the generator wrote -- which resolves the constructor, the fields and the + * injection methods up front -- and replaces it with a definition that has to find all of that + * by reflection, which is what a generated image does not carry. So the generated one stands and + * this one is dropped.

    + * + *

    Anything the generator did not produce a definition for is registered as usual, so a bean a + * plugin contributes conditionally is unaffected. On a normal start nothing is skipped, and a + * plugin overrides what came before it exactly as it did.

    + */ + private void register(BeanDefinitionRegistry registry, String beanName, BeanDefinition definition) { + if (AotDetector.useGeneratedArtifacts() && registry.containsBeanDefinition(beanName)) { + if (LOG.isDebugEnabled()) { + LOG.debug("[RuntimeConfiguration] Keeping the generated definition of bean [" + beanName + "]"); + } + return; + } + registry.registerBeanDefinition(beanName, definition); + } + private void registerBeanConfigsWithRegistry(BeanDefinitionRegistry registry) { for (BeanConfiguration bc : beanConfigs.values()) { String beanName = bc.getName(); @@ -285,7 +311,7 @@ private void registerBeanConfigsWithRegistry(BeanDefinitionRegistry registry) { } } - registry.registerBeanDefinition(beanName, bc.getBeanDefinition()); + register(registry, beanName, bc.getBeanDefinition()); } } @@ -302,7 +328,7 @@ private void registerBeanDefinitionsWithRegistry(BeanDefinitionRegistry registry } } final String beanName = key.toString(); - registry.registerBeanDefinition(beanName, bd); + register(registry, beanName, bd); } } diff --git a/grails-spring/src/test/groovy/org/grails/spring/DefaultRuntimeSpringConfigurationAotSpec.groovy b/grails-spring/src/test/groovy/org/grails/spring/DefaultRuntimeSpringConfigurationAotSpec.groovy new file mode 100644 index 00000000000..827388e09eb --- /dev/null +++ b/grails-spring/src/test/groovy/org/grails/spring/DefaultRuntimeSpringConfigurationAotSpec.groovy @@ -0,0 +1,96 @@ +/* + * 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.grails.spring + +import org.springframework.aot.AotDetector +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.beans.factory.support.RootBeanDefinition +import org.springframework.core.SpringProperties +import spock.lang.Specification + +/** + * Covers plugin bean definitions being registered without replacing ones generated ahead of time. + * + *

    Running on generated artifacts, the plugins that produced these definitions already ran: they + * ran while the artifacts were being generated, and what they registered was written out as code and + * registered again ahead of this phase. Registering over that discards the instance supplier the + * generator wrote and replaces it with a definition that finds everything by reflection.

    + */ +class DefaultRuntimeSpringConfigurationAotSpec extends Specification { + + DefaultListableBeanFactory registry = new DefaultListableBeanFactory() + + DefaultRuntimeSpringConfiguration springConfig = new DefaultRuntimeSpringConfiguration() + + void cleanup() { + SpringProperties.setProperty(AotDetector.AOT_ENABLED, null) + } + + private void runningOnGeneratedArtifacts(boolean enabled) { + SpringProperties.setProperty(AotDetector.AOT_ENABLED, String.valueOf(enabled)) + } + + /** A definition contributed the way a plugin's {@code doWithSpring()} contributes one. */ + private void contribute(String beanName, Class beanClass) { + springConfig.addSingletonBean(beanName, beanClass) + } + + void 'a generated definition is kept'() { + given: + runningOnGeneratedArtifacts(true) + RootBeanDefinition generated = new RootBeanDefinition(Collaborator) + registry.registerBeanDefinition('subject', generated) + contribute('subject', Collaborator) + + when: + springConfig.registerBeansWithRegistry(registry) + + then: + registry.getBeanDefinition('subject').is(generated) + } + + void 'a definition the generator did not produce is still registered'() { + given: + runningOnGeneratedArtifacts(true) + contribute('conditional', Collaborator) + + when: + springConfig.registerBeansWithRegistry(registry) + + then: 'a bean a plugin contributes conditionally has nothing generated for it' + registry.containsBeanDefinition('conditional') + } + + void 'a plugin overrides what came before it on a normal start'() { + given: + runningOnGeneratedArtifacts(false) + RootBeanDefinition earlier = new RootBeanDefinition(Collaborator) + registry.registerBeanDefinition('subject', earlier) + contribute('subject', Collaborator) + + when: + springConfig.registerBeansWithRegistry(registry) + + then: 'the ordering plugins rely on to replace one another is unchanged' + !registry.getBeanDefinition('subject').is(earlier) + } + + static class Collaborator { + } +} From d2ad00cc77fc51bee90d0d97480d87a9e78f7ce6 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 16:34:08 -0700 Subject: [PATCH 025/115] Do not add a second processor for configuration classes The core plugin registers a ConfigurationClassPostProcessor so that @Configuration beans contributed by plugins get parsed. A context that annotation configuration has already been set up on has one of its own, and the plugin definitions are registered ahead of it, so it sees them: the second processor parses the same registry over again. While code is being generated the two of them each contribute a registration of the import-aware post-processor, so the generated initializer registers it twice under one name and the second replaces the first on every start -- the last overriding definition message an ahead-of-time application reported. It is now registered only where there is none: a context assembled without that step, such as a test slice registering this plugin's beans on a bare registry, which is what it was for. An ahead-of-time application now starts with no overridden bean definitions at all. (cherry picked from commit fa92bd33942f3ebdf5d76ae200e044cd3ab95374) --- .../grails/plugins/CoreGrailsPlugin.groovy | 27 +++++++++++++++++-- .../plugins/CoreGrailsPluginAotSpec.groovy | 16 +++++++++++ 2 files changed, 41 insertions(+), 2 deletions(-) diff --git a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy index 3824e08ff2f..7cbdfedf6eb 100644 --- a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy +++ b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy @@ -30,6 +30,9 @@ import org.springframework.beans.factory.xml.XmlBeanDefinitionReader import org.springframework.boot.autoconfigure.AutoConfiguration import org.springframework.boot.autoconfigure.AutoConfigureOrder import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration +import org.springframework.context.ApplicationContext +import org.springframework.context.ConfigurableApplicationContext +import org.springframework.context.annotation.AnnotationConfigUtils import org.springframework.context.annotation.ConfigurationClassPostProcessor import org.springframework.context.support.GenericApplicationContext import org.springframework.context.support.PropertySourcesPlaceholderConfigurer @@ -119,6 +122,21 @@ class CoreGrailsPlugin extends Plugin { } } + /** + * Whether the context already has a processor that parses configuration classes. + * + *

    Spring registers one under a well-known name as part of setting up annotation + * configuration, which is every application context that reads annotations. A context assembled + * without that step -- a test slice registering this plugin's beans on a bare registry -- has + * none, and is what the plugin's own processor is for.

    + */ + private static boolean hasConfigurationClassPostProcessor(GrailsApplication application) { + ApplicationContext context = application.mainContext + context instanceof ConfigurableApplicationContext && + ((ConfigurableApplicationContext) context).beanFactory.containsBeanDefinition( + AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME) + } + /** * Scans the packages named by {@code grails.spring.bean.packages}. Contributed here rather * than through {@code doWithSpring}'s {@code grailsContext:component-scan} element, which @@ -133,8 +151,13 @@ class CoreGrailsPlugin extends Plugin { // enable post-processing of @Configuration beans defined by plugins. An AOT-optimized // context has no ConfigurationClassPostProcessor of its own: the configuration classes // were parsed at build time and their beans are already in the generated initializer, - // so registering one here would parse them a second time. - if (!AotDetector.useGeneratedArtifacts()) { + // so registering one here would parse them a second time. A context that annotation + // configuration has already been set up on has one of its own, which sees the plugin + // definitions because they are registered ahead of it; a second processor over the same + // registry parses everything a second time, and while code is being generated the two of + // them write out the same import-aware post-processor twice, so one registration + // replaces the other on every start. + if (!AotDetector.useGeneratedArtifacts() && !hasConfigurationClassPostProcessor(application)) { registry.registerBean('grailsConfigurationClassPostProcessor', ConfigurationClassPostProcessor) } diff --git a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy index 84ce4e450fc..8c1d98f2c74 100644 --- a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy @@ -25,6 +25,7 @@ import org.springframework.aot.generate.InMemoryGeneratedFiles import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.support.BeanRegistryAdapter import org.springframework.beans.factory.support.GenericBeanDefinition +import org.springframework.context.annotation.AnnotationConfigUtils import org.springframework.context.aot.ApplicationContextAotGenerator import org.springframework.context.support.GenericApplicationContext import org.springframework.core.SpringProperties @@ -102,6 +103,21 @@ class CoreGrailsPluginAotSpec extends Specification { !context.containsBeanDefinition('grailsConfigurationClassPostProcessor') } + void 'a second configuration class post-processor is not added to a context that has one'() { + given: 'the processor Spring registers as part of setting up annotation configuration' + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + AnnotationConfigUtils.registerAnnotationConfigProcessors(context) + + when: + applyCorePluginRegistrar() + + then: 'the one already there sees the plugin definitions, which are registered ahead of it; ' + + 'a second parses the same registry again and, while code is being generated, writes ' + + 'out the same import-aware post-processor a second time' + !context.containsBeanDefinition('grailsConfigurationClassPostProcessor') + context.containsBeanDefinition(AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME) + } + void 'the core plugin bean definitions can be generated ahead of time'() { given: SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') From ee481ed20798d659645447272c28249ef2f4ac58 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 16:37:03 -0700 Subject: [PATCH 026/115] Cover the two ahead-of-time processors contributing to one bean Both decorate the same generated block of definition properties, one after the other, and no bean in the application under test happens to draw on both, so nothing was proving they compose. A bean that is autowired by name and takes a variable-argument constructor argument now shows both contributions surviving. (cherry picked from commit 65ce6fbe9e52b7bc197c896118891aec08085296) --- ...VarargsBeanRegistrationAotProcessorSpec.groovy | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy index 0e544488dc6..f24d672738d 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy @@ -23,6 +23,7 @@ import org.springframework.aot.generate.DefaultGenerationContext import org.springframework.aot.generate.GeneratedFiles import org.springframework.aot.generate.InMemoryGeneratedFiles import org.springframework.beans.factory.config.RuntimeBeanReference +import org.springframework.beans.factory.support.AbstractBeanDefinition import org.springframework.beans.factory.support.RootBeanDefinition import org.springframework.context.aot.ApplicationContextAotGenerator import org.springframework.context.support.GenericApplicationContext @@ -49,8 +50,10 @@ class VarargsBeanRegistrationAotProcessorSpec extends Specification { } /** The generated source for a context holding one bean with the given constructor arguments. */ - private String generatedSourceFor(Class beanClass, List arguments) { + private String generatedSourceFor(Class beanClass, List arguments, + int autowireMode = AbstractBeanDefinition.AUTOWIRE_NO) { RootBeanDefinition definition = new RootBeanDefinition(beanClass) + definition.autowireMode = autowireMode arguments.each { definition.constructorArgumentValues.addGenericArgumentValue(it) } context.registerBeanDefinition('subject', definition) @@ -121,6 +124,16 @@ class VarargsBeanRegistrationAotProcessorSpec extends Specification { !generated.contains('new Class[]') } + void 'a bean that is also autowired keeps both contributions'() { + when: 'two processors decorate the same generated properties, one after the other' + String generated = generatedSourceFor(Registration, ['*.gsp'], + AbstractBeanDefinition.AUTOWIRE_BY_NAME) + + then: 'neither displaces the other' + generated.contains('new String[] {"*.gsp"}') + generated.contains("setAutowireMode(${AbstractBeanDefinition.AUTOWIRE_BY_NAME})") + } + void 'a bean built with no arguments is untouched'() { when: String generated = generatedSourceFor(Registration, []) From c250a955da61d2ce790b9f66e0e16404b95735ea Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 17:01:31 -0700 Subject: [PATCH 027/115] Let a plugin declare its beans from inside an image A plugin declares them in a closure, and Groovy resolves each call in a closure where the call is written rather than when the closure is compiled, so every call on the registry it is handed is made reflectively. An image keeps a method for that only when something has asked it to, and nothing did: the registry belongs to Spring, an application never names it, and the closures that call it are registered as closures rather than for what they call. So the image refused the first call and the context did not start, reporting a method of an interface that appears nowhere in the application. It stood only as long as an application's own traced metadata happened to cover the framework's API, which is not the application's to know. Verified by a native image, which now starts. (cherry picked from commit c4cfdaf7e8997fe71b56720c61497ce2b0374228) --- .../beans/aot/BeanRegistrarRuntimeHints.java | 60 +++++++++++++++ .../resources/META-INF/spring/aot.factories | 1 + .../aot/BeanRegistrarRuntimeHintsSpec.groovy | 74 +++++++++++++++++++ 3 files changed, 135 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java new file mode 100644 index 00000000000..1b7400422c6 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java @@ -0,0 +1,60 @@ +/* + * 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.grails.spring.beans.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.beans.factory.BeanRegistrar; +import org.springframework.beans.factory.BeanRegistry; +import org.springframework.lang.Nullable; + +/** + * Registers the registry a plugin declares its beans against. + * + *

    A plugin declares them in a closure, and Groovy resolves every call in a closure where the call + * is written rather than when the closure is compiled. So each call on the registry is made + * reflectively, and an image keeps a method for that only when something has asked it to.

    + * + *

    Nothing does: the registry belongs to Spring, an application never names it, and the closures + * that call it are registered as closures rather than for what they call. The image then refuses the + * first call and the context does not start, reporting a method of an interface that appears nowhere + * in the application -- a plugin declaring a bean with a specification, which most of them do.

    + * + *

    The types are named here rather than scanned for, because they belong to Spring and are few.

    + * + * @since 8.0 + */ +public class BeanRegistrarRuntimeHints implements RuntimeHintsRegistrar { + + /** The registry, what hands a plugin to it, and the types its calls pass through. */ + private static final Class[] TYPES = { + BeanRegistrar.class, + BeanRegistry.class, + BeanRegistry.Spec.class, + BeanRegistry.SupplierContext.class + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (Class type : TYPES) { + hints.reflection().registerType(type, MemberCategory.INVOKE_DECLARED_METHODS); + } + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index 88fbea2056b..dc867446676 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -2,6 +2,7 @@ org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter=\ org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.spring.beans.aot.BeanRegistrarRuntimeHints,\ org.grails.spring.beans.aot.GrailsClosureRuntimeHints org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..86af0cf6600 --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.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.grails.spring.beans.aot + +import java.util.function.Consumer + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeHint +import org.springframework.aot.hint.TypeReference +import org.springframework.beans.factory.BeanRegistrar +import org.springframework.beans.factory.BeanRegistry +import spock.lang.Specification + +/** + * Covers the registry a plugin declares its beans against being callable from an image. + * + *

    A plugin declares them in a closure, so every call on the registry is made reflectively. An + * image keeps a method for that only when asked, nothing else asks for these, and the failure is a + * context that does not start naming an interface the application never mentions.

    + */ +class BeanRegistrarRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new BeanRegistrarRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private TypeHint hintFor(Class type) { + hints.reflection().getTypeHint(TypeReference.of(type)) + } + + void 'the registry a plugin declares its beans against can be called'() { + expect: + hintFor(BeanRegistry)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the specification a plugin configures a bean through can be called'() { + expect: 'registerBean(name, type) { ... } calls onto it for every bean so declared' + hintFor(BeanRegistry.Spec)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + hintFor(BeanRegistry.SupplierContext)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'what hands a plugin to the registry can be called'() { + expect: + hintFor(BeanRegistrar)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the call a plugin actually makes is covered'() { + given: 'the three-argument form, which is what a bean with a specification uses' + def registerBean = BeanRegistry.getMethod('registerBean', String, Class, Consumer) + + expect: 'declared methods covers it, so the image keeps it' + registerBean.declaringClass == BeanRegistry + hintFor(BeanRegistry).memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } +} From 07273ed9e1ea7bb7dcd4619acf919ca90a9d5eb8 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 17:01:46 -0700 Subject: [PATCH 028/115] Answer where the application runs, not where it was built, for GSP Two decisions in the GSP plugin were settled while the bean definitions were being generated and written into them, and generation runs in the project directory. Both then described the machine that built the application rather than the one that runs it. Nothing showed while the plugin re-registered its beans on every start and corrected them; now that the generated definitions stand, the answers are the ones that survive. Where the pages compiled at build time are listed is no longer decided here. It is attached whatever the surroundings, because whether to read from it is decided where a page is looked up, at run time, and only there is the answer knowable. Deciding it here left an image with no list at all, so it looked for the sources instead and tried to compile them -- defining a class at run time being the one thing such an image cannot do. Every page returned a server error. The list is named rather than resolved, so what is written down is a location to look in and not a path on the machine that did the building. Whether the application is being developed now answers no while code is being generated. Generation sees a project directory around it and would otherwise register a page loader rooted at the build machine's own path -- writing that path into the artifact -- and would settle reloading and cache timeouts as though the application were being worked on. Verified by a native image: pages render, and the build machine's directory no longer appears in the generated sources for these beans. (cherry picked from commit ffe04f122d9229c47ef96c6f3e28b5816ecf3f16) --- .../web/GroovyPagesGrailsPlugin.groovy | 50 ++++++++++--------- 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index 71984c7a799..4b23c2bb8e4 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -21,12 +21,12 @@ package org.grails.plugins.web import groovy.transform.CompileStatic import groovy.util.logging.Slf4j -import org.springframework.aot.AotDetector import org.springframework.beans.factory.BeanRegistry import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.config.PropertiesFactoryBean import org.springframework.boot.web.servlet.ServletRegistrationBean -import org.springframework.core.io.Resource +import org.springframework.context.aot.AbstractAotProcessor +import org.springframework.core.SpringProperties import org.springframework.util.ClassUtils import org.springframework.web.servlet.view.InternalResourceViewResolver @@ -187,32 +187,22 @@ class GroovyPagesGrailsPlugin extends Plugin { } } - // An ahead-of-time image reads the pages compiled at build time whatever its - // surroundings suggest. It can be run from the directory it was built in, where a - // development environment is available, and it still cannot compile a page: defining a - // class at run time is what such an image gives up. - def deployed = !Metadata.getCurrent().isDevelopmentEnvironmentAvailable() || - AotDetector.useGeneratedArtifacts() groovyPageLocator(CachingGrailsConventionGroovyPageLocator) { bean -> bean.lazyInit = true if (customResourceLoader) { resourceLoader = groovyPageResourceLoader } - if (deployed) { - Resource defaultViews = applicationContext?.getResource('gsp/views.properties') - - if (defaultViews != null) { - if (!defaultViews.exists()) { - defaultViews = applicationContext?.getResource('classpath:gsp/views.properties') - } - } - - if (defaultViews?.exists()) { - precompiledGspMap = { PropertiesFactoryBean pfb -> - ignoreResourceNotFound = true - locations = [defaultViews] as Resource[] - } - } + // Where the pages compiled at build time are listed. Attached whatever the + // surroundings, because whether to read from it is decided where a page is looked + // up, at run time, and only there is the answer knowable: deciding it here settles + // it while the definition is being generated, in the directory the application was + // built in, where a development environment is available -- so an image would be + // built believing it has to compile its pages, which is the one thing it cannot do. + // Named rather than resolved, so that what is written down is a location to look in + // and not a path on the machine that did the building. + precompiledGspMap = { PropertiesFactoryBean pfb -> + ignoreResourceNotFound = true + locations = ['gsp/views.properties', 'classpath:gsp/views.properties'] } if (enableReload) { cacheTimeout = gspCacheTimeout @@ -289,7 +279,21 @@ class GroovyPagesGrailsPlugin extends Plugin { } } + /** + * Whether the application is being developed, which decides where its pages are read from and + * whether they are watched for change. + * + *

    While code is being generated the answer is no, whatever the machine doing the generating + * looks like. Generation runs in the project directory, so a development environment is + * available there and the question would otherwise be answered for the machine that built the + * application rather than the one that runs it: the pages would be read from a directory that + * exists only on the build machine, whose path would be written into the artifact, and an image + * cannot compile a page it finds there in any case.

    + */ protected boolean isDevelopmentMode() { + if (SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING)) { + return false + } Metadata.getCurrent().isDevelopmentEnvironmentAvailable() } From 32e3467b6474be11d24653527132af9051b5669f Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 17:01:58 -0700 Subject: [PATCH 029/115] Leave the Hibernate datastore's configuration to be read where it runs too The Mongo and Neo4j initializers stopped handing their datastore the configuration object itself; Hibernate, which is the datastore most applications use, was left holding it. Generating code for that definition writes out everything the resolver can reach -- the environment of the machine that ran the build, credentials among them -- and the application then reads its settings from there rather than from where it runs. Both the Hibernate 5 and Hibernate 7 initializers now name the environment while code is being generated, as the others do. The configuration is still read directly for the decisions made as the definitions are built, which are decisions either way. What a definition holds in place of the configuration now has tests of its own, covering the reference while code is being generated, the resolver every other time, a registry with no environment to name, and the classes a datastore maps being the array its constructor takes. None of this was covered, which is how Hibernate came to be missed. (cherry picked from commit 9c1cc3094963121ceab73826d9d39cdcf43cc11c) --- ...HibernateDatastoreSpringInitializer.groovy | 3 +- ...HibernateDatastoreSpringInitializer.groovy | 3 +- ...tastoreInitializerConfigurationSpec.groovy | 132 ++++++++++++++++++ 3 files changed, 136 insertions(+), 2 deletions(-) create mode 100644 grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy diff --git a/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy b/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy index 62727e13dc1..7d4b037d3d8 100644 --- a/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy +++ b/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy @@ -145,13 +145,14 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { hibernateProxyHandler(HibernateProxyHandler) def config = this.configuration + Object configurationReference = configurationReference(beanDefinitionRegistry) final boolean isGrailsPresent = isGrailsPresent() dataSourceConnectionSourceFactory(CachedDataSourceConnectionSourceFactory) hibernateConnectionSourceFactory(HibernateConnectionSourceFactory, persistentClasses as Class[]) { bean -> bean.autowire = true dataSourceConnectionSourceFactory = ref('dataSourceConnectionSourceFactory') } - hibernateDatastore(HibernateDatastore, config, hibernateConnectionSourceFactory, eventPublisher) { bean -> + hibernateDatastore(HibernateDatastore, configurationReference, hibernateConnectionSourceFactory, eventPublisher) { bean -> bean.primary = true } sessionFactory(hibernateDatastore: 'getSessionFactory') { bean -> diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy b/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy index 58940a847fb..bcd83fd0f9e 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy @@ -165,6 +165,7 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { hibernateBytecodeProvider(GrailsBytecodeProvider) def config = this.configuration + Object configurationReference = configurationReference(beanDefinitionRegistry) final boolean isGrailsPresent = isGrailsPresent() def appContext = this.applicationContext dataSourceConnectionSourceFactory(CachedDataSourceConnectionSourceFactory) @@ -175,7 +176,7 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { applicationContext = appContext } } - hibernateDatastore(HibernateDatastore, config, hibernateConnectionSourceFactory, eventPublisher) { bean -> + hibernateDatastore(HibernateDatastore, configurationReference, hibernateConnectionSourceFactory, eventPublisher) { bean -> bean.primary = true } sessionFactory(hibernateDatastore: 'getSessionFactory') { bean -> diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy new file mode 100644 index 00000000000..992bc95666b --- /dev/null +++ b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy @@ -0,0 +1,132 @@ +/* + * 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.grails.datastore.gorm.bootstrap + +import org.springframework.beans.factory.config.RuntimeBeanReference +import org.springframework.beans.factory.support.BeanDefinitionRegistry +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.context.ConfigurableApplicationContext +import org.springframework.context.aot.AbstractAotProcessor +import org.springframework.context.support.GenericApplicationContext +import org.springframework.core.env.MapPropertySource +import spock.lang.Specification + +/** + * Covers what a datastore's bean definition holds in place of the configuration. + * + *

    A definition holding the resolver is a definition holding everything that resolver can reach, + * and generating code for it writes those values out -- the environment of whatever machine ran the + * build, credentials among them, and settings that are meant to differ where the application runs. + * So while code is being generated the environment is named instead. Every other time the resolver + * is held as before, which is what a datastore brought up on its own depends on: its configuration + * is whatever the caller passed, and no environment holds it.

    + */ +class AbstractDatastoreInitializerConfigurationSpec extends Specification { + + GenericApplicationContext context = new GenericApplicationContext() + + void cleanup() { + System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) + context.close() + } + + private void whileGeneratingCode(boolean generating) { + generating ? System.setProperty(AbstractAotProcessor.AOT_PROCESSING, 'true') + : System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) + } + + private Initializer initializerFor(Map configuration) { + context.environment.propertySources.addFirst(new MapPropertySource('test', configuration)) + new Initializer(configuration) + } + + void 'the configuration is held as it stands on an ordinary start'() { + given: + Initializer initializer = initializerFor(['grails.mongodb.databaseName': 'foo']) + whileGeneratingCode(false) + + when: + Object held = initializer.configurationReferenceFor(context) + + then: 'a datastore brought up on its own has no environment carrying its settings' + held.is(initializer.configuration) + } + + void 'the environment is named while code is being generated'() { + given: + Initializer initializer = initializerFor(['grails.mongodb.databaseName': 'foo']) + whileGeneratingCode(true) + + when: + Object held = initializer.configurationReferenceFor(context) + + then: 'so the lookup is made where the application runs, not written down where it was built' + held instanceof RuntimeBeanReference + ((RuntimeBeanReference) held).beanName == ConfigurableApplicationContext.ENVIRONMENT_BEAN_NAME + } + + void 'a registry that is not a container keeps the configuration'() { + given: + Initializer initializer = new Initializer(['grails.mongodb.databaseName': 'foo']) + whileGeneratingCode(true) + + when: 'a bare registry, with no environment to name' + Object held = initializer.configurationReferenceFor(new DefaultListableBeanFactory()) + + then: + held.is(initializer.configuration) + } + + void 'the classes a datastore maps are the array its constructor takes'() { + given: + Initializer initializer = new Initializer([:]) + initializer.persistentClasses = [String, Integer] + + expect: 'a collection does not answer to Class[], and the argument is then missed when the ' + + 'definition is read to generate code for it' + initializer.mappedClassesFor('mongo') instanceof Class[] + initializer.mappedClassesFor('mongo').toList() == [String, Integer] + } + + /** Reaches the protected members through a subclass, the way a datastore's own initializer does. */ + static class Initializer extends AbstractDatastoreInitializer { + + Initializer(Map configuration) { + super(configuration) + } + + Object configurationReferenceFor(BeanDefinitionRegistry registry) { + configurationReference(registry) + } + + Class[] mappedClassesFor(String datastoreType) { + collectMappedClasses(datastoreType) + } + + @Override + Closure getBeanDefinitions(BeanDefinitionRegistry beanDefinitionRegistry) { + return { } + } + + @Override + Class getPersistenceInterceptorClass() { + Object + } + } +} From a650c420877811ea3cda3414df6e86def2d27289 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 17:21:14 -0700 Subject: [PATCH 030/115] Inherit no search location while code is being generated The locations a resource locator inherits are directories on the machine that registers them, and a child definition merges them in. Generating code for that child writes them into it, so an application carried the directory it was built in and looked there for its resources -- a path that says where it was built and, wherever it then runs, is not where its resources are. Nothing showed while the plugins re-registered these beans on every start and replaced the merged definition; now that the generated definitions stand, the build machine's directory is what an application would use. A generated application reads its resources from its own contents instead, which is what is left when there is nowhere named to look. One change at the definition every resource locator inherits from, so it holds for the ones the framework registers and for a third-party plugin's alike -- asset-pipeline's among them, whose locator carried the same path. The generated sources for an ahead-of-time application no longer contain the build directory anywhere. The post-processor also had no tests; it has them now. (cherry picked from commit 5302e1c6ccd536700bfd8f6a6156eba205d3eb14) --- .../AbstractResourceLocatorPostProcessor.java | 19 +++- ...actResourceLocatorPostProcessorSpec.groovy | 96 +++++++++++++++++++ 2 files changed, 114 insertions(+), 1 deletion(-) create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java index 7149a707ece..b53bec5af07 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java @@ -26,7 +26,9 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.beans.factory.support.GenericBeanDefinition; +import org.springframework.context.aot.AbstractAotProcessor; import org.springframework.core.PriorityOrdered; +import org.springframework.core.SpringProperties; /** * Registers {@code abstractGrailsResourceLocator}, the abstract parent definition that @@ -61,10 +63,25 @@ public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) t } GenericBeanDefinition definition = new GenericBeanDefinition(); definition.setAbstract(true); - definition.getPropertyValues().add("searchLocations", this.searchLocations); + definition.getPropertyValues().add("searchLocations", searchLocationsToInherit()); registry.registerBeanDefinition(BEAN_NAME, definition); } + /** + * The locations to be inherited, which while code is being generated are none. + * + *

    These are directories on the machine this runs on, and a child definition merges them in. + * Generating code for that child writes them into it, so an application would carry the + * directory it was built in and look for its resources there -- a path that says where it was + * built and, wherever it then runs, is not where its resources are. A generated application + * reads them from its own contents instead, which is what is left when there is nowhere named + * to look.

    + */ + private List searchLocationsToInherit() { + return SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING) ? + List.of() : this.searchLocations; + } + /** * Ordered first, because a child definition naming this one as its parent cannot be merged * until it exists, and merging happens as soon as anything resolves beans by type. diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy new file mode 100644 index 00000000000..de2e1d2dd73 --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy @@ -0,0 +1,96 @@ +/* + * 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.grails.spring.beans + +import org.springframework.beans.factory.support.BeanDefinitionRegistry +import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.beans.factory.support.RootBeanDefinition +import org.springframework.context.aot.AbstractAotProcessor +import spock.lang.Specification + +/** + * Covers the search locations a resource locator inherits. + * + *

    They are directories on the machine this runs on, and a child definition merges them in. + * Generating code for that child writes them into it, so an application would carry the directory it + * was built in and look there for its resources -- a path that says where it was built and, wherever + * it runs, is not where its resources are.

    + */ +class AbstractResourceLocatorPostProcessorSpec extends Specification { + + BeanDefinitionRegistry registry = new DefaultListableBeanFactory() + + void cleanup() { + System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) + } + + private void whileGeneratingCode(boolean generating) { + generating ? System.setProperty(AbstractAotProcessor.AOT_PROCESSING, 'true') + : System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) + } + + private List registeredSearchLocations() { + registry.getBeanDefinition(AbstractResourceLocatorPostProcessor.BEAN_NAME) + .propertyValues.getPropertyValue('searchLocations').value as List + } + + void 'the locations are inherited on an ordinary start'() { + given: + whileGeneratingCode(false) + + when: + new AbstractResourceLocatorPostProcessor(['/base']).postProcessBeanDefinitionRegistry(registry) + + then: + registeredSearchLocations() == ['/base'] + } + + void 'no location is inherited while code is being generated'() { + given: + whileGeneratingCode(true) + + when: + new AbstractResourceLocatorPostProcessor(['/base']).postProcessBeanDefinitionRegistry(registry) + + then: 'a generated application reads its resources from its own contents, and the directory ' + + 'it was built in belongs to the machine that built it' + registeredSearchLocations().isEmpty() + } + + void 'the definition is abstract, so it is inherited rather than built'() { + when: + new AbstractResourceLocatorPostProcessor(['/base']).postProcessBeanDefinitionRegistry(registry) + + then: + registry.getBeanDefinition(AbstractResourceLocatorPostProcessor.BEAN_NAME).abstract + } + + void 'a definition that is already registered is kept'() { + given: + RootBeanDefinition existing = new RootBeanDefinition() + existing.abstract = true + registry.registerBeanDefinition(AbstractResourceLocatorPostProcessor.BEAN_NAME, existing) + + when: + new AbstractResourceLocatorPostProcessor(['/base']).postProcessBeanDefinitionRegistry(registry) + + then: 'which is how an application overrides where its resources are looked for' + registry.getBeanDefinition(AbstractResourceLocatorPostProcessor.BEAN_NAME).is(existing) + } +} From d218534d4716404427d06235b3f3a6848d9aa7c2 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 17:21:14 -0700 Subject: [PATCH 031/115] Let an image call the classes that extend types Groovy did not declare A module names them in a descriptor rather than in any code, and Groovy calls the method it finds there through the metaclass -- so request.forwardURI reaches a static method on an extension class reflectively. An image keeps that method only when something asks it to, and nothing did. So the image refused the call where it was made. The framework extends the servlet request, the response and the session this way, and those are reached while a page is rendered, so what failed was a request rather than the start-up: most visibly the error page, which is the one page that renders when something has already gone wrong. A native image returned the right status for a record that was deleted and could not render the page that says so. The classes are read from the descriptors as the hints are written, so a module added later is covered without being named here, whether it belongs to the framework, a plugin or the application. (cherry picked from commit f628b92430547be548b20940b9e30069f5aecad4) --- .../GroovyExtensionModuleRuntimeHints.java | 133 ++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 3 +- ...oovyExtensionModuleRuntimeHintsSpec.groovy | 100 +++++++++++++ 3 files changed, 235 insertions(+), 1 deletion(-) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java new file mode 100644 index 00000000000..397c4bad57a --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java @@ -0,0 +1,133 @@ +/* + * 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.grails.spring.beans.aot; + +import java.io.IOException; +import java.io.InputStream; +import java.util.LinkedHashSet; +import java.util.Properties; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.core.io.Resource; +import org.springframework.core.io.support.PathMatchingResourcePatternResolver; +import org.springframework.core.io.support.ResourcePatternResolver; +import org.springframework.lang.Nullable; +import org.springframework.util.ClassUtils; +import org.springframework.util.StringUtils; + +import org.grails.aot.RegistrableTypes; + +/** + * Registers the classes that extend types Groovy did not declare. + * + *

    A module declares them in a descriptor, and Groovy calls the method it finds there through the + * metaclass rather than as a call written against the class -- so {@code request.forwardURI} reaches + * a static method on an extension class reflectively. An image keeps that method only when asked, + * and nothing asks: the extension class is named in a descriptor rather than in any code.

    + * + *

    The image then refuses the call where it is made. The framework extends the servlet request, + * the response, the session and more this way, and those are reached while rendering a page, so what + * fails is a request rather than the start-up -- most visibly the error page, which is the one page + * that renders when something has already gone wrong.

    + * + *

    Read from the descriptors while the hints are written, so a module added later is covered + * without being named here, whether it belongs to the framework, a plugin or the application.

    + * + * @since 8.0 + */ +public class GroovyExtensionModuleRuntimeHints implements RuntimeHintsRegistrar { + + private static final Log logger = LogFactory.getLog(GroovyExtensionModuleRuntimeHints.class); + + private static final String DESCRIPTOR_NAME = "org.codehaus.groovy.runtime.ExtensionModule"; + + /** Both places Groovy reads module descriptors from. */ + private static final String[] DESCRIPTORS = { + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "META-INF/services/" + DESCRIPTOR_NAME, + ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + "META-INF/groovy/" + DESCRIPTOR_NAME + }; + + /** The two kinds of extension a descriptor names: one extends instances, the other the type. */ + private static final String[] CLASS_PROPERTIES = { "extensionClasses", "staticExtensionClasses" }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); + ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); + Set extensionClasses = new LinkedHashSet<>(); + for (String descriptor : DESCRIPTORS) { + collectFrom(resolver, descriptor, extensionClasses); + } + int registered = 0; + for (String className : extensionClasses) { + if (RegistrableTypes.loads(className, loader)) { + hints.reflection().registerTypeIfPresent(loader, className, + MemberCategory.INVOKE_DECLARED_METHODS); + registered++; + } + } + logger.debug("Registered " + registered + " Groovy extension classes for reflection"); + } + + private void collectFrom(ResourcePatternResolver resolver, String descriptor, Set collected) { + Resource[] resources; + try { + resources = resolver.getResources(descriptor); + } + catch (IOException ex) { + logger.warn("Unable to read Groovy extension modules from " + descriptor, ex); + return; + } + for (Resource resource : resources) { + Properties module = read(resource); + if (module == null) { + continue; + } + for (String property : CLASS_PROPERTIES) { + for (String className : StringUtils.commaDelimitedListToStringArray( + module.getProperty(property, ""))) { + String trimmed = className.trim(); + if (!trimmed.isEmpty()) { + collected.add(trimmed); + } + } + } + } + } + + /** A descriptor that cannot be read names nothing, which is what an unreadable one contributes. */ + @Nullable + private Properties read(Resource resource) { + try (InputStream input = resource.getInputStream()) { + Properties module = new Properties(); + module.load(input); + return module; + } + catch (IOException | RuntimeException ex) { + logger.warn("Unable to read Groovy extension module " + resource, ex); + return null; + } + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index dc867446676..0d488193e1b 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -3,7 +3,8 @@ org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter org.springframework.aot.hint.RuntimeHintsRegistrar=\ org.grails.spring.beans.aot.BeanRegistrarRuntimeHints,\ -org.grails.spring.beans.aot.GrailsClosureRuntimeHints +org.grails.spring.beans.aot.GrailsClosureRuntimeHints,\ +org.grails.spring.beans.aot.GroovyExtensionModuleRuntimeHints org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ org.grails.spring.beans.aot.AutowireModeBeanRegistrationAotProcessor,\ diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..39da074843d --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy @@ -0,0 +1,100 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +/** + * Covers the classes that extend types Groovy did not declare being callable from an image. + * + *

    A module names them in a descriptor rather than in any code, and Groovy calls them through the + * metaclass, so nothing else asks an image to keep them. The failure is a request rather than the + * start-up: the framework extends the servlet request and response this way, and those are reached + * while a page is rendered.

    + */ +class GroovyExtensionModuleRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new GroovyExtensionModuleRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private Set registeredTypes() { + hints.reflection().typeHints().collect { it.type.name } as Set + } + + private boolean invocable(String className) { + invocableIn(hints, className) + } + + private boolean invocableIn(RuntimeHints target, String className) { + def hint = target.reflection().getTypeHint(TypeReference.of(className)) + hint != null && hint.memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the extensions the framework declares are registered'() { + expect: 'these are named only in a descriptor, so nothing else would ask for them' + registeredTypes().any { it.endsWith('Extension') } + } + + void 'both kinds of extension a descriptor names are registered'() { + given: 'a descriptor of this spec\'s own, so the assertion does not rest on what happens to ' + + 'be on the classpath of the module the registrar lives in' + File directory = File.createTempDir() + new File(directory, 'META-INF/services').mkdirs() + new File(directory, 'META-INF/services/org.codehaus.groovy.runtime.ExtensionModule').text = ''' + moduleName=spec-module + moduleVersion=1.0 + extensionClasses=java.lang.StringBuilder + staticExtensionClasses=java.lang.StringBuffer + '''.stripIndent() + RuntimeHints declared = new RuntimeHints() + + when: + new GroovyExtensionModuleRuntimeHints().registerHints(declared, + new URLClassLoader([directory.toURI().toURL()] as URL[], getClass().classLoader)) + + then: 'one extends instances and the other the type; a call is made through either' + invocableIn(declared, 'java.lang.StringBuilder') + invocableIn(declared, 'java.lang.StringBuffer') + + cleanup: + directory.deleteDir() + } + + void 'every extension named by a descriptor can have its methods called'() { + expect: 'registering the type without its methods still leaves the call refused' + registeredTypes().findAll { it.endsWith('Extension') }.every { invocable(it) } + } + + void 'a class loader that resolves nothing yields no hints rather than failing'() { + given: + RuntimeHints empty = new RuntimeHints() + + when: + new GroovyExtensionModuleRuntimeHints().registerHints(empty, new URLClassLoader(new URL[0], null)) + + then: + noExceptionThrown() + } +} From 33c54d8c452444f48099468f69d9da8e20646f87 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 17:22:07 -0700 Subject: [PATCH 032/115] Read the flag directly rather than looking it up The plugin descriptor is not statically compiled, so Groovy resolved the constant naming the flag where it is read -- reflectively, on a class an image has not been asked to keep anything of. The context did not start. Compiling the one method statically turns it into a direct read, which is what a constant should be. Only the image saw this: on a JVM the lookup succeeds, so the same code that runs there fails once it is compiled. (cherry picked from commit 76d775c58dcfd2349b1fd988f5516f1e12c370e0) --- .../groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy | 1 + 1 file changed, 1 insertion(+) diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index 4b23c2bb8e4..ae982ed436c 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -290,6 +290,7 @@ class GroovyPagesGrailsPlugin extends Plugin { * exists only on the build machine, whose path would be written into the artifact, and an image * cannot compile a page it finds there in any case.

    */ + @CompileStatic protected boolean isDevelopmentMode() { if (SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING)) { return false From 0d0dc239d17ccded28414c4c2ad5ba928d2ba137 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 18:59:45 -0700 Subject: [PATCH 033/115] Do not read the application's own bean declarations a second time An application declares beans of its own in spring/resources.groovy, and these are read while the artifacts are being generated: what they declare is written out as code and registered from there. Reading them again at start-up registers them a second time, and reading the Groovy one means compiling a script -- which is the one thing an image cannot do. So an application that has a spring/resources.groovy, as one generated by Forge does, did not start at all: Error loading spring/resources.groovy file: Classes cannot be defined at runtime by default when using ahead-of-time Native Image compilation Verified by a native image rather than by a test: the post-processor takes a refreshed context and a plugin manager to construct, so nothing exercises it below the level of an application starting, and a test that read the guard back off the source would assert nothing about behaviour. (cherry picked from commit c7e1fefff4cce61b3c354bd6a476f3bab8fdb155) --- .../boot/config/GrailsApplicationPostProcessor.groovy | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy b/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy index cbdbd415f45..c37840bfb5a 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy @@ -256,7 +256,12 @@ class GrailsApplicationPostProcessor implements BeanDefinitionRegistryPostProces pluginManager.doRuntimeConfiguration(springConfig) } - if (loadExternalBeans) { + // Running on generated artifacts these beans are already registered: the application's own + // definitions were read while the artifacts were being generated and what they declared was + // written out as code. Reading them again would register them a second time, and reading + // the Groovy one means compiling a script -- which an image cannot do at all, so an + // application that has a spring/resources.groovy did not start. + if (loadExternalBeans && !AotDetector.useGeneratedArtifacts()) { // now allow overriding via application def context = application.mainContext From 2b0824fef572d1aef21b6b6dfe28600ed0f8efc1 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 19:27:08 -0700 Subject: [PATCH 034/115] Write down the artefacts an application is made of An application's artefacts are found two ways, and an image has neither: the classpath is scanned for the classes under the application's own packages, which needs a classpath to walk, and a list the compile-time transform builds as it goes is consulted, which lives in a static field and is empty in anything the transform did not itself compile. So an image found no controllers, no domain classes and no URL mappings, and the application failed to start on the first bean that wanted one. The only way to start was to override classes() and name every artefact by hand -- a list to keep in step with the application forever after, and one an application should not have to know it needs. They are found while the code is generated, on an ordinary JVM where both ways work, so what was found is written into the generated code and read back by classes(). An application declares nothing and keeps nothing in step. Nothing is written down where nothing was found, so a plain Spring application being generated is unaffected, and on an ordinary start the two ways are used as they always were. Verified on a generated application that declares no artefacts of its own: the generated initializer carries all 32 of them, its own UrlMappings and User among them, where before it carried none. (cherry picked from commit 7b5c501d61b012f28d49ccd8704eb3994f2a6cea) --- .../config/GrailsAutoConfiguration.groovy | 31 +++++ ...BeanFactoryInitializationAotProcessor.java | 126 ++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 3 + ...ctoryInitializationAotProcessorSpec.groovy | 120 +++++++++++++++++ 4 files changed, 280 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy b/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy index 6e800e43982..3ce991577b5 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy @@ -26,6 +26,8 @@ import org.springframework.aop.config.AopConfigUtils import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationContextAware import org.springframework.context.annotation.Bean +import org.springframework.aot.AotDetector +import org.springframework.beans.factory.config.SingletonBeanRegistry import org.springframework.core.io.support.PathMatchingResourcePatternResolver import grails.boot.config.tools.ClassPathScanner @@ -34,6 +36,7 @@ import grails.core.GrailsApplication import grails.core.GrailsApplicationClass import org.apache.grails.core.plugins.PluginDiscovery import org.grails.spring.aop.autoproxy.GroovyAwareAspectJAwareAdvisorAutoProxyCreator +import org.grails.spring.beans.aot.ArtefactClassesBeanFactoryInitializationAotProcessor import org.grails.spring.aop.autoproxy.GroovyAwareInfrastructureAdvisorAutoProxyCreator /** @@ -78,6 +81,11 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont * @return The classes that constitute the Grails application */ Collection classes() { + Collection written = artefactsWrittenDownAheadOfTime() + if (written != null) { + return written + } + if (limitScanningToApplication()) { return ApplicationArtefactScanner.scanApplicationClasses(getClass(), packageNames()) } @@ -88,6 +96,29 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont return classes } + /** + * The artefacts written down while the application's code was generated, or {@code null} where + * nothing was written down and they are to be found the usual ways. + * + *

    Both usual ways need something an image does not have: one walks the classpath, the other + * reads a list the compile-time transform builds as it goes, which is empty in anything the + * transform did not itself compile. So an image found no artefacts at all, and an application + * could only start by naming its own -- a list to keep in step with itself forever after.

    + * + *

    They were found while the code was generated, on an ordinary JVM where both ways work, and + * left here.

    + */ + protected Collection artefactsWrittenDownAheadOfTime() { + if (applicationContext == null || !AotDetector.useGeneratedArtifacts()) { + return null + } + Object written = applicationContext.autowireCapableBeanFactory instanceof SingletonBeanRegistry + ? ((SingletonBeanRegistry) applicationContext.autowireCapableBeanFactory) + .getSingleton(ArtefactClassesBeanFactoryInitializationAotProcessor.BEAN_NAME) + : null + written instanceof Class[] ? Arrays.asList((Class[]) written) : null + } + /** * Whether classpath scanning should be limited to the application and not dependent JAR files. Users can override this method to enable more broad scanning * at the cost of startup time. diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java new file mode 100644 index 00000000000..31af8aab939 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java @@ -0,0 +1,126 @@ +/* + * 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.grails.spring.beans.aot; + +import java.util.ArrayList; +import java.util.List; + +import javax.lang.model.element.Modifier; + +import org.springframework.aot.generate.GeneratedMethod; +import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution; +import org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor; +import org.springframework.beans.factory.aot.BeanFactoryInitializationCode; +import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; +import org.springframework.javapoet.CodeBlock; +import org.springframework.lang.Nullable; + +import grails.core.GrailsApplication; + +/** + * Writes down the artefacts an application is made of, while they can still be found. + * + *

    They are found two ways, and an image has neither. The classpath is scanned for the classes + * under the application's own packages, which needs a classpath to walk; and a list the compile-time + * transform builds as it goes is consulted, which lives in a static field of the transform and is + * therefore empty in anything the transform did not itself compile.

    + * + *

    So an image found no controllers, no domain classes and no URL mappings, and the application + * failed to start on the first bean that wanted one. The only way an application could start was to + * override {@code classes()} and list its own artefacts by hand, which is a thing to keep in step + * with the application forever after.

    + * + *

    Generation runs on an ordinary JVM with the full classpath, where both ways work. What they + * found is written into the generated code here, and read back by {@link + * grails.boot.config.GrailsAutoConfiguration#classes()}.

    + * + * @since 8.0 + */ +public class ArtefactClassesBeanFactoryInitializationAotProcessor implements BeanFactoryInitializationAotProcessor { + + /** + * Where the classes are left for {@code classes()} to find. A singleton rather than a bean + * definition, because it is read while the definitions are still being contributed. + */ + public static final String BEAN_NAME = "grailsArtefactClasses"; + + @Override + @Nullable + public BeanFactoryInitializationAotContribution processAheadOfTime(ConfigurableListableBeanFactory beanFactory) { + List> artefacts = artefactsOf(beanFactory); + if (artefacts.isEmpty()) { + return null; + } + return (generationContext, beanFactoryInitializationCode) -> + contribute(artefacts, beanFactoryInitializationCode); + } + + /** + * The artefacts the application was found to be made of, or none if this is not a Grails + * application context -- a plain Spring one being generated has no {@code grailsApplication}. + */ + private List> artefactsOf(ConfigurableListableBeanFactory beanFactory) { + List> artefacts = new ArrayList<>(); + Object application = beanFactory.getSingleton(GrailsApplication.APPLICATION_ID); + if (!(application instanceof GrailsApplication grailsApplication)) { + return artefacts; + } + Class[] allClasses = grailsApplication.getAllClasses(); + if (allClasses == null) { + return artefacts; + } + for (Class artefact : allClasses) { + if (artefact != null && isNamed(artefact)) { + artefacts.add(artefact); + } + } + return artefacts; + } + + /** + * Whether the class can be written down and read back. One generated as the application ran -- + * a proxy, or a script compiled from a string -- has a name that resolves to nothing next time. + */ + private boolean isNamed(Class artefact) { + return !artefact.isSynthetic() && !artefact.isAnonymousClass() && + !artefact.isLocalClass() && artefact.getCanonicalName() != null; + } + + private void contribute(List> artefacts, BeanFactoryInitializationCode beanFactoryInitializationCode) { + GeneratedMethod method = beanFactoryInitializationCode.getMethods() + .add("registerArtefactClasses", builder -> { + builder.addJavadoc("Register the artefacts this application is made of."); + builder.addModifiers(Modifier.PUBLIC, Modifier.STATIC); + builder.addParameter(ConfigurableListableBeanFactory.class, + BeanFactoryInitializationCode.BEAN_FACTORY_VARIABLE); + builder.addStatement("$L.registerSingleton($S, $L)", + BeanFactoryInitializationCode.BEAN_FACTORY_VARIABLE, BEAN_NAME, arrayOf(artefacts)); + }); + beanFactoryInitializationCode.addInitializer(method.toMethodReference()); + } + + /** The classes as an array literal, in the order they were found, so a run reads as a build did. */ + private CodeBlock arrayOf(List> artefacts) { + CodeBlock.Builder array = CodeBlock.builder().add("new $T[] {", Class.class); + for (int i = 0; i < artefacts.size(); i++) { + array.add(i == 0 ? "$T.class" : ", $T.class", artefacts.get(i)); + } + return array.add("}").build(); + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index 0d488193e1b..f263d9e0f9d 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -9,3 +9,6 @@ org.grails.spring.beans.aot.GroovyExtensionModuleRuntimeHints org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ org.grails.spring.beans.aot.AutowireModeBeanRegistrationAotProcessor,\ org.grails.spring.beans.aot.VarargsBeanRegistrationAotProcessor + +org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor=\ +org.grails.spring.beans.aot.ArtefactClassesBeanFactoryInitializationAotProcessor diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy new file mode 100644 index 00000000000..308b7321ef3 --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy @@ -0,0 +1,120 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.aot.generate.ClassNameGenerator +import org.springframework.aot.generate.DefaultGenerationContext +import org.springframework.aot.generate.GeneratedFiles +import org.springframework.aot.generate.InMemoryGeneratedFiles +import org.springframework.context.aot.ApplicationContextAotGenerator +import org.springframework.context.support.GenericApplicationContext +import org.springframework.javapoet.ClassName +import spock.lang.Specification + +import grails.core.DefaultGrailsApplication +import grails.core.GrailsApplication + +/** + * Covers the artefacts an application is made of being written down while they can still be found. + * + *

    They are found by walking the classpath and by reading a list the compile-time transform builds + * as it goes, and an image has neither -- so it found no controllers, no domain classes and no URL + * mappings, and the application failed to start on the first bean that wanted one. The only way to + * start was for an application to name its own artefacts by hand.

    + */ +class ArtefactClassesBeanFactoryInitializationAotProcessorSpec extends Specification { + + GenericApplicationContext context = new GenericApplicationContext() + + void cleanup() { + context.close() + } + + private String generatedSourceFor(Class... artefacts) { + GrailsApplication application = new DefaultGrailsApplication(artefacts) + application.applicationContext = context + application.initialise() + context.beanFactory.registerSingleton(GrailsApplication.APPLICATION_ID, application) + + InMemoryGeneratedFiles generatedFiles = new InMemoryGeneratedFiles() + DefaultGenerationContext generationContext = new DefaultGenerationContext( + new ClassNameGenerator(ClassName.get('com.example', 'Subject')), generatedFiles) + new ApplicationContextAotGenerator().processAheadOfTime(context, generationContext) + generationContext.writeGeneratedContent() + + generatedFiles.getGeneratedFiles(GeneratedFiles.Kind.SOURCE) + .keySet() + .collect { generatedFiles.getGeneratedFileContent(GeneratedFiles.Kind.SOURCE, it) } + .join('\n') + } + + void 'the artefacts are written into the generated code'() { + when: + String generated = generatedSourceFor(DemoController, DemoService) + + then: 'so that an image has them without the application naming them itself' + generated.contains('registerSingleton("grailsArtefactClasses"') + generated.contains('DemoController.class') + generated.contains('DemoService.class') + } + + void 'the registration is run as the bean factory is initialized'() { + when: + String generated = generatedSourceFor(DemoController) + + then: 'they are read while the definitions are still being contributed, so they have to be ' + + 'there before any of them is' + generated.contains('registerArtefactClasses') + } + + void 'a context that is not a Grails application contributes nothing'() { + given: + def processor = new ArtefactClassesBeanFactoryInitializationAotProcessor() + + expect: 'a plain Spring application being generated has no grailsApplication to ask' + processor.processAheadOfTime(context.beanFactory) == null + } + + void 'the classes that constitute the application are what is written down'() { + when: 'a Grails application holds these as the classes it is made of' + String generated = generatedSourceFor(DemoController, DemoService) + + then: 'which is what classes() answers with, so a run reads what a build found' + generated.count('.class') >= 2 + } + + void 'an application with no artefacts contributes nothing'() { + given: + GrailsApplication application = new DefaultGrailsApplication() + application.applicationContext = context + application.initialise() + context.beanFactory.registerSingleton(GrailsApplication.APPLICATION_ID, application) + + expect: 'writing an empty array down would say the application has none, which is different ' + + 'from not having looked' + new ArtefactClassesBeanFactoryInitializationAotProcessor() + .processAheadOfTime(context.beanFactory) == null + } + + static class DemoController { + } + + static class DemoService { + } +} From 26f464bef9b684b178a2b98fe3209a04d1c85aa8 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 20:25:34 -0700 Subject: [PATCH 035/115] Leave the plugins' own artefacts to the plugins Writing down every class the application holds wrote down the plugins' artefacts too -- their tag libraries and codecs, which they register from themselves on every start. The application then claimed them as its own and they were registered twice, which for a codec is not the same as registering it once: a page rendered through one asked for static text that the other had never been given, and every page that renders any failed on a null. What the plugins provide is asked of the plugins and left to them, so an application writes down its own and nothing else -- for the application under test its six, where before it was all thirty-two. (cherry picked from commit 9f2e54e9d3227483ca1f33dbc513168450d2a06f) --- ...BeanFactoryInitializationAotProcessor.java | 30 ++++++++++++- ...ctoryInitializationAotProcessorSpec.groovy | 43 +++++++++++++++++++ 2 files changed, 72 insertions(+), 1 deletion(-) diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java index 31af8aab939..00c661f2fb8 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java @@ -19,7 +19,10 @@ package org.grails.spring.beans.aot; import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import javax.lang.model.element.Modifier; @@ -32,6 +35,8 @@ import org.springframework.lang.Nullable; import grails.core.GrailsApplication; +import grails.plugins.GrailsPlugin; +import grails.plugins.GrailsPluginManager; /** * Writes down the artefacts an application is made of, while they can still be found. @@ -85,14 +90,37 @@ private List> artefactsOf(ConfigurableListableBeanFactory beanFactory) if (allClasses == null) { return artefacts; } + Set> providedByPlugins = providedByPlugins(beanFactory); for (Class artefact : allClasses) { - if (artefact != null && isNamed(artefact)) { + if (artefact != null && isNamed(artefact) && !providedByPlugins.contains(artefact)) { artefacts.add(artefact); } } return artefacts; } + /** + * The artefacts the plugins bring with them, which are not the application's to declare. + * + *

    They are registered from the plugins on every start, so writing them down here would have + * the application claim them as its own -- and a codec or a tag library registered twice, once + * as a plugin's and once as the application's, is not the same as registered once.

    + */ + private Set> providedByPlugins(ConfigurableListableBeanFactory beanFactory) { + Set> provided = new LinkedHashSet<>(); + Object manager = beanFactory.getSingleton(GrailsPluginManager.BEAN_NAME); + if (!(manager instanceof GrailsPluginManager pluginManager)) { + return provided; + } + for (GrailsPlugin plugin : pluginManager.getAllPlugins()) { + Class[] artefacts = plugin.getProvidedArtefacts(); + if (artefacts != null) { + provided.addAll(Arrays.asList(artefacts)); + } + } + return provided; + } + /** * Whether the class can be written down and read back. One generated as the application ran -- * a proxy, or a script compiled from a string -- has a name that resolves to nothing next time. diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy index 308b7321ef3..dd2813dacc0 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy @@ -29,6 +29,8 @@ import spock.lang.Specification import grails.core.DefaultGrailsApplication import grails.core.GrailsApplication +import grails.plugins.GrailsPlugin +import grails.plugins.GrailsPluginManager /** * Covers the artefacts an application is made of being written down while they can still be found. @@ -112,6 +114,47 @@ class ArtefactClassesBeanFactoryInitializationAotProcessorSpec extends Specifica .processAheadOfTime(context.beanFactory) == null } + void "what the plugins bring with them is not written down"() { + given: "a plugin manager whose plugins provide one of the classes the application holds" + GrailsApplication application = new DefaultGrailsApplication(DemoController, DemoService) + application.applicationContext = context + application.initialise() + context.beanFactory.registerSingleton(GrailsApplication.APPLICATION_ID, application) + context.beanFactory.registerSingleton(GrailsPluginManager.BEAN_NAME, + Stub(GrailsPluginManager) { + getAllPlugins() >> ([Stub(GrailsPlugin) { + getProvidedArtefacts() >> ([DemoService] as Class[]) + }] as GrailsPlugin[]) + }) + + when: + def contribution = new ArtefactClassesBeanFactoryInitializationAotProcessor() + .processAheadOfTime(context.beanFactory) + + then: "they are registered from the plugins on every start, and a codec or tag library " + + "registered twice is not the same as registered once" + contribution != null + + and: + def written = writtenBy(contribution) + written.contains(DemoController) + !written.contains(DemoService) + } + + /** The classes the contribution would write, read back off the code it generates. */ + private List writtenBy(contribution) { + InMemoryGeneratedFiles files = new InMemoryGeneratedFiles() + DefaultGenerationContext generation = new DefaultGenerationContext( + new ClassNameGenerator(ClassName.get('com.example', 'Written')), files) + new ApplicationContextAotGenerator().processAheadOfTime(context, generation) + generation.writeGeneratedContent() + String source = files.getGeneratedFiles(GeneratedFiles.Kind.SOURCE) + .keySet() + .collect { files.getGeneratedFileContent(GeneratedFiles.Kind.SOURCE, it) } + .join('\n') + [DemoController, DemoService].findAll { source.contains(it.simpleName + '.class') } + } + static class DemoController { } From f3041206244aa84e0ba742c88c997ed69a087e66 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 20:25:34 -0700 Subject: [PATCH 036/115] Define the url mappings holder as reloadable only where it can reload Reloading swaps the mappings behind a proxy, and that proxy produces its UrlMappings through a target source rather than declaring the type -- so Spring can only learn what it produces by building it, which is exactly what reading a generated definition avoids. Generated that way, nothing could be autowired by that type: Field urlMappings in UrlMappingsErrorPageCustomizer required a bean of type 'grails.web.mapping.UrlMappings' that could not be found and the application did not start. Generation runs in the project directory, where the surroundings look like development, so this is what an application got unless it knew to generate its code with the environment set to production. Reloading is now off while the code is being generated, whatever the machine generating it looks like -- an image cannot reload anything in any case. The surroundings still decide on an ordinary start. The decision is its own method so that both answers can be tested; before, the only way to reach it was to be in surroundings that reload. (cherry picked from commit 5c77de08159229667d479244327d867d46039bd5) --- .../mapping/UrlMappingsGrailsPlugin.groovy | 24 +++++++++- .../UrlMappingsGrailsPluginSpec.groovy | 45 +++++++++++++++++++ 2 files changed, 67 insertions(+), 2 deletions(-) diff --git a/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy b/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy index 1824e739b36..24b7680c775 100644 --- a/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy +++ b/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy @@ -30,6 +30,8 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication import org.springframework.boot.context.properties.EnableConfigurationProperties import org.springframework.context.ApplicationContext +import org.springframework.context.aot.AbstractAotProcessor +import org.springframework.core.SpringProperties import org.springframework.core.env.Environment import org.springframework.web.filter.CorsFilter @@ -117,8 +119,7 @@ class UrlMappingsGrailsPlugin extends Plugin { grailsApplication.addArtefact(UrlMappingsArtefactHandler.TYPE, DefaultUrlMappings) } - boolean reloadEnabled = GrailsEnvironment.developmentMode || - GrailsEnvironment.current.reloadEnabled + boolean reloadEnabled = isReloadEnabled() boolean corsFilterEnabled = environment.getProperty(Settings.SETTING_CORS_FILTER, Boolean, true) // The url-mapping holder is a ProxyFactoryBean (reload mode) whose produced UrlMappings @@ -155,6 +156,25 @@ class UrlMappingsGrailsPlugin extends Plugin { } } + /** + * Whether the mappings are to be reloadable, which decides how the holder is defined. + * + *

    Not while the code is being generated, whatever the machine generating it looks like. + * Reloading swaps the mappings behind a proxy, and the proxy produces its {@code UrlMappings} + * through a target source rather than declaring the type -- so Spring can only learn what it + * produces by building it, which is exactly what reading a generated definition avoids. + * Generated that way nothing could be autowired by that type, and the application did not + * start. An image cannot reload anything in any case.

    + */ + protected boolean isReloadEnabled() { + !SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING) && environmentReloadable + } + + /** Whether the surroundings are ones that reload, which only a run can answer. */ + protected boolean isEnvironmentReloadable() { + GrailsEnvironment.developmentMode || GrailsEnvironment.current.reloadEnabled + } + @CompileStatic private static UrlMappingsHolder createUrlMappingsHolder(ApplicationContext applicationContext) { def factory = new UrlMappingsHolderFactoryBean(applicationContext: applicationContext) diff --git a/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy b/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy index 289100a3f0b..f4a97541762 100644 --- a/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy +++ b/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy @@ -23,6 +23,7 @@ import org.springframework.beans.factory.config.RuntimeBeanReference import org.springframework.beans.factory.support.AbstractBeanDefinition import org.springframework.beans.factory.support.BeanRegistryAdapter import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.context.aot.AbstractAotProcessor import org.springframework.core.env.StandardEnvironment import grails.core.GrailsApplication @@ -103,6 +104,50 @@ class UrlMappingsGrailsPluginSpec extends Specification { !registry.containsBeanDefinition('urlMappingsTargetSource') } + void "reloading is off while the code is being generated"() { + given: "surroundings that would otherwise reload" + def plugin = new Reloading() + + expect: "which is how the holder comes to be a proxy" + plugin.isReloadEnabled() + + when: "the same surroundings, while the code is being generated" + System.setProperty(AbstractAotProcessor.AOT_PROCESSING, 'true') + + then: "the proxy produces its UrlMappings through a target source rather than declaring the " + + "type, so nothing could be autowired by that type from a generated definition" + !plugin.isReloadEnabled() + + cleanup: + System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) + } + + void "the surroundings still decide on an ordinary start"() { + given: + System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) + + expect: "generation is the only thing that overrides them" + new Reloading().isReloadEnabled() + !new NotReloading().isReloadEnabled() + } + + /** Stands in for surroundings that reload, which a test JVM is not. */ + static class Reloading extends UrlMappingsGrailsPlugin { + + @Override + protected boolean isEnvironmentReloadable() { + true + } + } + + static class NotReloading extends UrlMappingsGrailsPlugin { + + @Override + protected boolean isEnvironmentReloadable() { + false + } + } + private static void applyRegistrar(DefaultListableBeanFactory beanFactory, GrailsApplication application) { def plugin = new UrlMappingsGrailsPlugin(grailsApplication: application) def registrar = plugin.beanRegistrar() From 9ba4d149a1d6bc14e92c01225a14336c9a9b7aad Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 20:25:34 -0700 Subject: [PATCH 037/115] Carry what a page compiled at build time is read from Compiling a page splits it: the code becomes a class, and the static text between the code -- most of the page -- is written beside it as a resource that the class reads as it renders, along with the line numbers mapping the generated code back to the page. An image carries a resource only when it has been asked to, and nothing asked for these: they are named by a convention rather than by any code. Every page then rendered with nothing where its text should be and reported a null from inside the page's own generated code, which says nothing about a missing resource. They are asked for here, so an application does not have to know the names of files the compiler chose. (cherry picked from commit 0235ecc06b2f3c92b7b4dc7708131e5b3939cf6c) --- .../gsp/aot/PrecompiledPageRuntimeHints.java | 51 +++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + .../PrecompiledPageRuntimeHintsSpec.groovy | 64 +++++++++++++++++++ 3 files changed, 117 insertions(+) create mode 100644 grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java create mode 100644 grails-gsp/core/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy diff --git a/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java b/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java new file mode 100644 index 00000000000..2e10774ca24 --- /dev/null +++ b/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java @@ -0,0 +1,51 @@ +/* + * 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.grails.gsp.aot; + +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +import org.grails.gsp.GroovyPageMetaInfo; + +/** + * Registers what a page compiled at build time is read from. + * + *

    Compiling a page splits it: the code becomes a class, and the static text between the code -- + * most of the page -- is written beside it as a resource, along with the line numbers that map the + * generated code back to the page it came from. The class reads that resource as it renders.

    + * + *

    An image carries a resource only when it has been asked to, and nothing asked for these: they + * are named by a convention rather than by any code. The page then rendered with nothing where its + * text should be, and reported a null the page itself could not explain.

    + * + * @since 8.0 + */ +public class PrecompiledPageRuntimeHints implements RuntimeHintsRegistrar { + + /** Where the pages compiled at build time are listed, read to find them at all. */ + private static final String VIEWS = "gsp/views.properties"; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + hints.resources().registerPattern(VIEWS); + hints.resources().registerPattern("*" + GroovyPageMetaInfo.HTML_DATA_POSTFIX); + hints.resources().registerPattern("*" + GroovyPageMetaInfo.LINENUMBERS_DATA_POSTFIX); + } +} diff --git a/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories b/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..178ec340883 --- /dev/null +++ b/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +org.grails.gsp.aot.PrecompiledPageRuntimeHints diff --git a/grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy b/grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..9eea0dbe87b --- /dev/null +++ b/grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy @@ -0,0 +1,64 @@ +/* + * 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.grails.gsp.aot + +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.predicate.RuntimeHintsPredicates +import spock.lang.Specification + +/** + * Covers what a page compiled at build time is read from being carried into an image. + * + *

    Compiling a page splits it: the code becomes a class, and the static text between the code -- + * most of the page -- is written beside it as a resource that the class reads as it renders. An + * image carries a resource only when asked, and these are named by convention rather than by any + * code, so nothing asked. Every page then rendered with nothing where its text should be.

    + */ +class PrecompiledPageRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new PrecompiledPageRuntimeHints().registerHints(hints, getClass().classLoader) + } + + void 'the static text of a compiled page is carried'() { + expect: 'without it the page renders empty and reports a null it cannot explain' + RuntimeHintsPredicates.resource() + .forResource('gsp_demo_indexgsp_html.data') + .test(hints) + } + + void 'the line numbers that map generated code back to the page are carried'() { + expect: + RuntimeHintsPredicates.resource() + .forResource('gsp_demo_indexgsp_linenumbers.data') + .test(hints) + } + + void 'the list of the pages compiled at build time is carried'() { + expect: 'read to find the compiled pages at all' + RuntimeHintsPredicates.resource().forResource('gsp/views.properties').test(hints) + } + + void 'an unrelated resource is not carried'() { + expect: 'the patterns name the compiled pages rather than everything' + !RuntimeHintsPredicates.resource().forResource('application.yml').test(hints) + } +} From feb740f097406a5f2a3baa6a2bf9a2f13caa5041 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 20:58:48 -0700 Subject: [PATCH 038/115] Ship what an image needs with the framework rather than asking for it Building an application into an image needed the application to know things about Groovy and about Grails that are not its to know: that Groovy's plugin factory and Grails' build settings both read their surroundings the first time they are touched, and so must be left until the image runs; that Groovy reads a table of the methods it adds to every type, and its version, and the descriptors naming its extensions, as it starts; and that Grails reads a listing to find its plugins at all. None of it was discoverable. Leaving out the two initializations gave a NullPointerException from inside Groovy's metaclass registry before any application code ran, and leaving out the resources gave a page that rendered empty or a plugin that was never found -- in each case naming something the application had never heard of. The initializations ship as native-image.properties, because when a class is initialized is a property of the image and nothing in the Spring hint model expresses it. The resources ship as hints, beside the code that reads them. Both travel in the jar, so this holds for a build of any kind rather than for one Gradle configuration. The application under test now declares none of it and builds and runs the same: 0.715s to start, no overridden definitions, every page served. (cherry picked from commit 9c3f7c6cea8bc4d44965c746aeeacfe8b90ea78b) --- .../beans/aot/GrailsClosureRuntimeHints.java | 10 +++++++ .../GroovyExtensionModuleRuntimeHints.java | 19 ++++++++++++ .../grails-core/native-image.properties | 30 +++++++++++++++++++ .../aot/GrailsClosureRuntimeHintsSpec.groovy | 9 ++++++ ...oovyExtensionModuleRuntimeHintsSpec.groovy | 15 ++++++++++ 5 files changed, 83 insertions(+) create mode 100644 grails-core/src/main/resources/META-INF/native-image/org.apache.grails/grails-core/native-image.properties diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java index 68b972ea5b8..55881d9f1f0 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -51,12 +51,21 @@ * task is on the compile classpath but Ant is not on the runtime one, and registering it would make * the image analysis parse a class whose supertype is absent, failing the build.

    * + *

    Where the plugins are listed is carried into the image as well, since that is read to find + * them at all and an image carries a resource only when it has been asked to.

    + * * @since 8.0 */ public class GrailsClosureRuntimeHints implements RuntimeHintsRegistrar { private static final Log logger = LogFactory.getLog(GrailsClosureRuntimeHints.class); + /** + * Where the plugins are listed, read to find them at all. Written out rather than taken from + * {@code FactoriesLoaderSupport}, whose constant is a Groovy property and so not visible here. + */ + private static final String PLUGIN_LISTING = "META-INF/grails.factories"; + /** * Where the framework's closures are found. The first two cover its own packages; the third * covers plugin descriptors, which a plugin may declare in any package of its choosing -- the @@ -71,6 +80,7 @@ public class GrailsClosureRuntimeHints implements RuntimeHintsRegistrar { @Override public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + hints.resources().registerPattern(PLUGIN_LISTING); ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver); diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java index 397c4bad57a..e223b90d6df 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java @@ -55,6 +55,11 @@ *

    Read from the descriptors while the hints are written, so a module added later is covered * without being named here, whether it belongs to the framework, a plugin or the application.

    * + *

    The descriptors themselves are carried into the image too, along with the table of methods + * Groovy adds to every type. Both are read as the runtime starts, and an image carries a resource + * only when it has been asked to: without them Groovy cannot build its metaclasses at all, and + * fails before any application code runs.

    + * * @since 8.0 */ public class GroovyExtensionModuleRuntimeHints implements RuntimeHintsRegistrar { @@ -72,8 +77,22 @@ public class GroovyExtensionModuleRuntimeHints implements RuntimeHintsRegistrar /** The two kinds of extension a descriptor names: one extends instances, the other the type. */ private static final String[] CLASS_PROPERTIES = { "extensionClasses", "staticExtensionClasses" }; + /** + * What the Groovy runtime reads as it starts: the table of the methods it adds to every type, + * the version it reports, and the descriptors naming the extensions above. + */ + private static final String[] RESOURCES = { + "META-INF/dgminfo", + "META-INF/groovy-release-info.properties", + "META-INF/services/" + DESCRIPTOR_NAME, + "META-INF/groovy/" + DESCRIPTOR_NAME + }; + @Override public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String resource : RESOURCES) { + hints.resources().registerPattern(resource); + } ClassLoader loader = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader(); ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader); Set extensionClasses = new LinkedHashSet<>(); diff --git a/grails-core/src/main/resources/META-INF/native-image/org.apache.grails/grails-core/native-image.properties b/grails-core/src/main/resources/META-INF/native-image/org.apache.grails/grails-core/native-image.properties new file mode 100644 index 00000000000..966754ebc3c --- /dev/null +++ b/grails-core/src/main/resources/META-INF/native-image/org.apache.grails/grails-core/native-image.properties @@ -0,0 +1,30 @@ +# +# 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. +# +# Both of these read their surroundings the first time they are touched, so an image that +# initialized them while it was being built would answer for the machine that built it. +# +# - Groovy's plugin factory decides how it reaches the JDK it is running on, and an image +# initialized at build time carries a decision made against the build's JDK. Nothing then +# starts: its metaclass registry throws a NullPointerException before any application code runs. +# - Grails' build settings resolve the project directory, which exists only where the build ran. +# +# Args rather than hints because when a class is initialized is a property of the image, and +# nothing in the Spring hint model expresses it. +Args = --initialize-at-run-time=org.codehaus.groovy.vmplugin.VMPluginFactory \ + --initialize-at-run-time=grails.util.BuildSettings diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy index f33f20cad4a..64ed1b98f80 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy @@ -20,6 +20,7 @@ package org.grails.spring.beans.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.predicate.RuntimeHintsPredicates import org.springframework.aot.hint.TypeReference import spock.lang.Specification @@ -66,6 +67,14 @@ class GrailsClosureRuntimeHintsSpec extends Specification { } } + void 'where the plugins are listed is carried'() { + given: + new GrailsClosureRuntimeHints().registerHints(hints, getClass().classLoader) + + expect: 'read to find the plugins at all, and an image carries a resource only when asked' + RuntimeHintsPredicates.resource().forResource('META-INF/grails.factories').test(hints) + } + void 'a class loader that resolves nothing yields no hints rather than failing'() { when: new GrailsClosureRuntimeHints().registerHints(hints, new URLClassLoader(new URL[0], null)) diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy index 39da074843d..d73e1b14617 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy @@ -21,6 +21,7 @@ package org.grails.spring.beans.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints import org.springframework.aot.hint.TypeReference +import org.springframework.aot.hint.predicate.RuntimeHintsPredicates import spock.lang.Specification /** @@ -87,6 +88,20 @@ class GroovyExtensionModuleRuntimeHintsSpec extends Specification { registeredTypes().findAll { it.endsWith('Extension') }.every { invocable(it) } } + void 'what the Groovy runtime reads as it starts is carried'() { + expect: 'without these it cannot build its metaclasses, and fails before any application code' + resourceRegistered('META-INF/dgminfo') + resourceRegistered('META-INF/groovy-release-info.properties') + + and: 'and the descriptors naming the extensions, which is how it finds them' + resourceRegistered('META-INF/services/org.codehaus.groovy.runtime.ExtensionModule') + resourceRegistered('META-INF/groovy/org.codehaus.groovy.runtime.ExtensionModule') + } + + private boolean resourceRegistered(String resource) { + RuntimeHintsPredicates.resource().forResource(resource).test(hints) + } + void 'a class loader that resolves nothing yields no hints rather than failing'() { given: RuntimeHints empty = new RuntimeHints() From 7d2bad0f02ce528a6d15e57f20fb17b2c3fc8e4a Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 21:19:38 -0700 Subject: [PATCH 039/115] Colour the output of an image that is being run at a shell Spring Boot decides whether to colour its output by asking for the console, and an image answers that it has none even when it has one. So the same application whose start-up is coloured under bootRun arrives plain once it is built, for a reason that has nothing to do with where it is running, and the only way to get the colour back was to know to pass spring.output.ansi.enabled. What the environment names as the terminal is read instead, which an image does carry. That does not distinguish output being watched from output being redirected -- nothing in an image does, which is the difficulty -- so a shell that redirects to a file still gets the escapes. It does distinguish a shell from the places that name no terminal at all: a build, a container, a service manager, where the output is only ever read later. That is why the terminal is read rather than the colour simply forced on. An application that has said either way keeps what it said, and a JVM is left to Spring Boot, where asking for the console works. Verified on a native image run at a terminal with nothing passed to it: dim timestamps, green level, magenta pid, as under bootRun. (cherry picked from commit c5eb3e8d4e1acf59da151123b0dda2053238380c) --- .../GrailsEnvironmentPostProcessor.java | 46 +++++++++ ...ilsEnvironmentPostProcessorAnsiSpec.groovy | 96 +++++++++++++++++++ 2 files changed, 142 insertions(+) create mode 100644 grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java b/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java index 2650bb300be..79648fb61cd 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java @@ -22,6 +22,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -32,6 +33,7 @@ import org.springframework.core.Ordered; import org.springframework.core.env.ConfigurableEnvironment; import org.springframework.core.env.EnumerablePropertySource; +import org.springframework.core.env.MapPropertySource; import org.springframework.core.env.MutablePropertySources; import org.springframework.core.env.PropertySource; import org.springframework.core.io.Resource; @@ -74,8 +76,15 @@ public int getOrder() { return Ordered.HIGHEST_PRECEDENCE + 15; } + /** Where Spring Boot reads whether to colour its output. */ + private static final String ANSI_ENABLED = "spring.output.ansi.enabled"; + + /** Set in an image, and in nothing else. */ + private static final String IMAGE_CODE = "org.graalvm.nativeimage.imagecode"; + @Override public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { + colourTheOutputOfAnImageThatHasATerminal(environment); try { PluginDiscovery pluginDiscovery = bootstrapContext.get(PluginDiscovery.class); if (pluginDiscovery == null) { @@ -92,6 +101,43 @@ public void postProcessEnvironment(ConfigurableEnvironment environment, SpringAp } } + /** + * Colours the output of an image running at a terminal, which it otherwise cannot tell it has. + * + *

    Spring Boot decides by asking for the console, and an image answers that it has none even + * when it is being watched at a terminal. So the same application whose start-up is coloured + * under {@code bootRun} arrives plain once it is built, for a reason that has nothing to do with + * the terminal it is running at.

    + * + *

    What the environment names as the terminal is read instead, which an image does carry. + * That does not distinguish output being watched from output being redirected -- nothing in an + * image does, which is the whole difficulty -- so a shell that redirects to a file still gets + * the escapes. It does distinguish a shell from the places that name no terminal at all: a + * build, a container, a service manager, where the output is only ever read later and stays + * plain. An application that has said either way is left alone.

    + */ + void colourTheOutputOfAnImageThatHasATerminal(ConfigurableEnvironment environment) { + if (!isImage() || environment.containsProperty(ANSI_ENABLED)) { + return; + } + String terminal = terminal(); + if (terminal == null || terminal.isEmpty() || "dumb".equals(terminal)) { + return; + } + environment.getPropertySources().addLast(new MapPropertySource("grails.ansi.output", + Map.of(ANSI_ENABLED, "always"))); + } + + /** Whether this is running as an image, which only a run can answer. */ + protected boolean isImage() { + return System.getProperty(IMAGE_CODE) != null; + } + + /** What the environment names as the terminal, if it names one. */ + protected String terminal() { + return System.getenv("TERM"); + } + /** * Loads plugin configuration files ({@code plugin.yml} or {@code plugin.groovy}) * in the topologically sorted order and adds them to the environment's property sources. diff --git a/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy b/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy new file mode 100644 index 00000000000..c4b4b76b268 --- /dev/null +++ b/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy @@ -0,0 +1,96 @@ +/* + * 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 grails.boot.config + +import org.springframework.boot.bootstrap.DefaultBootstrapContext +import org.springframework.core.env.MapPropertySource +import org.springframework.core.env.StandardEnvironment +import spock.lang.Specification + +/** + * Covers an image colouring its output when it is being watched at a terminal. + * + *

    Spring Boot decides by asking for the console, and an image answers that it has none even when + * it has one -- so the same application whose start-up is coloured under bootRun arrives plain once + * it is built. What the environment names as the terminal is read instead, which an image does + * carry. It cannot tell output being watched from output being redirected -- nothing in an image + * can -- but it does tell a shell from a build, a container or a service manager.

    + */ +class GrailsEnvironmentPostProcessorAnsiSpec extends Specification { + + private static final String ANSI = 'spring.output.ansi.enabled' + + StandardEnvironment environment = new StandardEnvironment() + + private String ansiAfter(boolean image, String terminal) { + new Processor(image, terminal).colourTheOutputOfAnImageThatHasATerminal(environment) + environment.getProperty(ANSI) + } + + void 'an image at a terminal colours its output'() { + expect: + ansiAfter(true, 'xterm-256color') == 'always' + } + + void 'an image where nothing names a terminal stays plain'() { + expect: 'a build, a container or a service manager, whose output is only ever read later' + ansiAfter(true, null) == null + } + + void 'a terminal that cannot colour is left alone'() { + expect: + ansiAfter(true, 'dumb') == null + } + + void 'running on a JVM is left to Spring Boot'() { + expect: 'where asking for the console works, and answers for pipes too' + ansiAfter(false, 'xterm-256color') == null + } + + void 'an application that has said either way keeps what it said'() { + given: + environment.propertySources.addFirst(new MapPropertySource('test', [(ANSI): 'never'])) + + expect: + ansiAfter(true, 'xterm-256color') == 'never' + } + + /** Stands in for the two things only a run can answer. */ + static class Processor extends GrailsEnvironmentPostProcessor { + + private final boolean image + private final String terminal + + Processor(boolean image, String terminal) { + super(new DefaultBootstrapContext()) + this.image = image + this.terminal = terminal + } + + @Override + protected boolean isImage() { + image + } + + @Override + protected String terminal() { + terminal + } + } +} From 79f1dccc59bcdb6c734659472aa1987413c93ed0 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 21:51:30 -0700 Subject: [PATCH 040/115] Show the banner art in the framework's colour The art is printed as it is read, so an application starting at a terminal that colours everything else about its output has a plain banner above it. AnsiOutput writes the escapes only where colour has been enabled, so a terminal that cannot colour, a redirected log, and an application that has turned colour off all print exactly what they printed before. The width the versions beneath are centred on is measured before the colour is added, since the escapes are characters the terminal does not show and would otherwise push the versions off centre by as many as the colour cost. There were no tests for the banner; there are now, including one that reads the versions back with the escapes stripped and finds them where they were. (cherry picked from commit 03aaac246aff1276ea148069c1d2b0e46a4145d4) --- .../groovy/grails/boot/GrailsBanner.groovy | 17 +++- .../grails/boot/GrailsBannerColourSpec.groovy | 89 +++++++++++++++++++ 2 files changed, 105 insertions(+), 1 deletion(-) create mode 100644 grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 434245a18a4..77aebfe029d 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -24,6 +24,8 @@ import groovy.transform.stc.ClosureParams import groovy.transform.stc.SimpleType import org.springframework.boot.Banner +import org.springframework.boot.ansi.AnsiColor +import org.springframework.boot.ansi.AnsiOutput import org.springframework.boot.SpringBootVersion import org.springframework.core.SpringVersion import org.springframework.core.env.Environment @@ -63,8 +65,10 @@ class GrailsBanner implements Banner { bannerPaddingTop.times { out.println() } if (shouldDisplayArt(environment)) { def art = createBannerArt(environment) + // measured before colouring, so the escapes do not count towards the width the + // versions below are centred on bannerWidth = longestLineLength(art) ?: FALLBACK_BANNER_WIDTH - out.println(art) + out.println(colour(art)) artPaddingBottom.times { out.println() } } if (shouldDisplayVersions(environment)) { @@ -74,6 +78,17 @@ class GrailsBanner implements Banner { bannerPaddingBottom.times { out.println() } } + /** + * The art in the framework's colour, or as it stands where colour is off. + * + *

    {@link AnsiOutput} writes the escapes only where it has been enabled, so this is the same + * string on a terminal that cannot colour, in a redirected log, and wherever an application has + * turned colour off.

    + */ + protected String colour(String art) { + AnsiOutput.toString(AnsiColor.YELLOW, art, AnsiColor.DEFAULT) + } + /** * Creates the banner art to be displayed. * diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy new file mode 100644 index 00000000000..23831ac5ea9 --- /dev/null +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy @@ -0,0 +1,89 @@ +/* + * 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 grails.boot + +import org.springframework.boot.ansi.AnsiColor +import org.springframework.boot.ansi.AnsiOutput +import org.springframework.core.env.StandardEnvironment +import spock.lang.Specification + +/** + * Covers the banner art being shown in the framework's colour. + * + *

    The escapes are written only where colour has been enabled, and the width the versions beneath + * are centred on is measured before they are added -- otherwise they would count towards it and + * push the versions off centre by as many characters as the colour cost.

    + */ +class GrailsBannerColourSpec extends Specification { + + GrailsBanner banner = new GrailsBanner() + + void cleanup() { + AnsiOutput.setEnabled(AnsiOutput.Enabled.DETECT) + } + + private String printed() { + ByteArrayOutputStream bytes = new ByteArrayOutputStream() + banner.printBanner(new StandardEnvironment(), GrailsBannerColourSpec, new PrintStream(bytes)) + bytes.toString() + } + + void 'the art is yellow where colour is on'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + + expect: + banner.colour('art').startsWith(AnsiOutput.encode(AnsiColor.YELLOW)) + } + + void 'the art is left as it stands where colour is off'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.NEVER) + + expect: 'a redirected log, or an application that has turned colour off' + banner.colour('art') == 'art' + } + + void 'the banner carries the colour through to what is printed'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + + expect: + printed().contains(AnsiOutput.encode(AnsiColor.YELLOW)) + } + + void 'the versions stay where they were before the art was coloured'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.NEVER) + List plain = versionLines(printed()) + + when: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + List coloured = versionLines(printed().replaceAll(/\[[0-9;]*m/, '')) + + then: 'the width is measured before the escapes are added, so they do not count towards it' + coloured == plain + !plain.isEmpty() + } + + /** The centred lines beneath the art, which is where a mismeasured width would show. */ + private List versionLines(String output) { + output.readLines().findAll { it.contains('Grails:') || it.contains('Spring') } + } +} From af29982470285faa1ad94b1bb00e2745c05ee09b Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 22:55:57 -0700 Subject: [PATCH 041/115] Let an application choose the colour the banner art is shown in The colour was the framework's to pick, and an application that wanted another -- or wanted the banner left alone while everything else about its output is coloured -- had no way to say so. grails.banner.art.color takes a number for one of the 256 colours a terminal offers, a name for one of the eight it has always had, or none to leave the art as it stands. It sits beside grails.banner.art.file, which is where an application already goes to change the art itself. The default is amber rather than the plain yellow it was: one of the 256, chosen to read as the framework's own rather than as a terminal's idea of yellow. A value that is neither a number nor a name falls back to the default. Failing to start over the colour of a banner would be a poor trade, and the banner itself shows plainly that the value did not take. (cherry picked from commit 6d2b7a9eecdaa0db6c7072483243fa2e2b0ea336) --- .../groovy/grails/boot/GrailsBanner.groovy | 48 ++++++++++++--- .../grails/boot/GrailsBannerColourSpec.groovy | 59 +++++++++++++++++-- 2 files changed, 95 insertions(+), 12 deletions(-) diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 77aebfe029d..3ad9004f1d1 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -24,7 +24,9 @@ import groovy.transform.stc.ClosureParams import groovy.transform.stc.SimpleType import org.springframework.boot.Banner +import org.springframework.boot.ansi.Ansi8BitColor import org.springframework.boot.ansi.AnsiColor +import org.springframework.boot.ansi.AnsiElement import org.springframework.boot.ansi.AnsiOutput import org.springframework.boot.SpringBootVersion import org.springframework.core.SpringVersion @@ -45,6 +47,13 @@ class GrailsBanner implements Banner { private static final int FALLBACK_BANNER_WIDTH = 0 private static final String DEFAULT_BANNER_FILE = 'grails-banner.txt' + private static final String ART_COLOR_PROPERTY = 'grails.banner.art.color' + + /** One of the 256 colours a terminal offers: the amber the framework is shown in. */ + private static final String DEFAULT_ART_COLOR = '214' + + private static final String NO_COLOR = 'none' + String bannerFile = DEFAULT_BANNER_FILE int bannerPaddingTop = 1 int bannerPaddingBottom = 1 @@ -68,7 +77,7 @@ class GrailsBanner implements Banner { // measured before colouring, so the escapes do not count towards the width the // versions below are centred on bannerWidth = longestLineLength(art) ?: FALLBACK_BANNER_WIDTH - out.println(colour(art)) + out.println(colour(art, environment)) artPaddingBottom.times { out.println() } } if (shouldDisplayVersions(environment)) { @@ -79,14 +88,39 @@ class GrailsBanner implements Banner { } /** - * The art in the framework's colour, or as it stands where colour is off. + * The art in the configured colour, or as it stands where none is wanted. * - *

    {@link AnsiOutput} writes the escapes only where it has been enabled, so this is the same - * string on a terminal that cannot colour, in a redirected log, and wherever an application has - * turned colour off.

    + *

    {@link AnsiOutput} writes the escapes only where colour has been enabled, so this is the + * same string on a terminal that cannot colour, in a redirected log, and wherever an application + * has turned colour off.

    */ - protected String colour(String art) { - AnsiOutput.toString(AnsiColor.YELLOW, art, AnsiColor.DEFAULT) + protected String colour(String art, Environment environment) { + AnsiElement colour = resolveArtColour(environment) + colour == null ? art : AnsiOutput.toString(colour, art, AnsiColor.DEFAULT) + } + + /** + * The colour to show the art in, read from {@code grails.banner.art.color}. + * + *

    Takes a number for one of the 256 colours a terminal offers, a name for one of the eight + * it has always had ({@code red}, {@code bright_blue}), or {@code none} to leave the art as it + * stands. A value that is neither falls back to the default rather than failing to start over + * the colour of a banner.

    + */ + protected AnsiElement resolveArtColour(Environment environment) { + String configured = environment.getProperty(ART_COLOR_PROPERTY, String, DEFAULT_ART_COLOR) + if (!configured || configured.equalsIgnoreCase(NO_COLOR)) { + return null + } + if (configured.isInteger()) { + return Ansi8BitColor.foreground(configured.toInteger()) + } + try { + return AnsiColor.valueOf(configured.toUpperCase()) + } + catch (IllegalArgumentException ignored) { + return Ansi8BitColor.foreground(DEFAULT_ART_COLOR.toInteger()) + } } /** diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy index 23831ac5ea9..a7610849731 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy @@ -18,8 +18,10 @@ */ package grails.boot +import org.springframework.boot.ansi.Ansi8BitColor import org.springframework.boot.ansi.AnsiColor import org.springframework.boot.ansi.AnsiOutput +import org.springframework.core.env.MapPropertySource import org.springframework.core.env.StandardEnvironment import spock.lang.Specification @@ -34,22 +36,30 @@ class GrailsBannerColourSpec extends Specification { GrailsBanner banner = new GrailsBanner() + StandardEnvironment environment = new StandardEnvironment() + void cleanup() { AnsiOutput.setEnabled(AnsiOutput.Enabled.DETECT) } + private void configured(String colour) { + environment.propertySources.addFirst( + new MapPropertySource('test', ['grails.banner.art.color': colour])) + } + private String printed() { ByteArrayOutputStream bytes = new ByteArrayOutputStream() - banner.printBanner(new StandardEnvironment(), GrailsBannerColourSpec, new PrintStream(bytes)) + banner.printBanner(environment, GrailsBannerColourSpec, new PrintStream(bytes)) bytes.toString() } - void 'the art is yellow where colour is on'() { + void 'the art is the framework amber where nothing is configured'() { given: AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) expect: - banner.colour('art').startsWith(AnsiOutput.encode(AnsiColor.YELLOW)) + banner.colour('art', environment) + .startsWith(AnsiOutput.encode(Ansi8BitColor.foreground(214))) } void 'the art is left as it stands where colour is off'() { @@ -57,7 +67,46 @@ class GrailsBannerColourSpec extends Specification { AnsiOutput.setEnabled(AnsiOutput.Enabled.NEVER) expect: 'a redirected log, or an application that has turned colour off' - banner.colour('art') == 'art' + banner.colour('art', environment) == 'art' + } + + void 'an application chooses one of the 256 colours by number'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + configured('45') + + expect: + banner.colour('art', environment) + .startsWith(AnsiOutput.encode(Ansi8BitColor.foreground(45))) + } + + void 'an application chooses one of the eight by name'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + configured('bright_blue') + + expect: 'read without regard to case, as configuration is written either way' + banner.colour('art', environment) + .startsWith(AnsiOutput.encode(AnsiColor.BRIGHT_BLUE)) + } + + void 'an application asks for no colour at all'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + configured('none') + + expect: 'colour everywhere else, and a banner left as it stands' + banner.colour('art', environment) == 'art' + } + + void 'a colour that means nothing falls back rather than failing to start'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + configured('chartreuse') + + expect: + banner.colour('art', environment) + .startsWith(AnsiOutput.encode(Ansi8BitColor.foreground(214))) } void 'the banner carries the colour through to what is printed'() { @@ -65,7 +114,7 @@ class GrailsBannerColourSpec extends Specification { AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) expect: - printed().contains(AnsiOutput.encode(AnsiColor.YELLOW)) + printed().contains(AnsiOutput.encode(Ansi8BitColor.foreground(214))) } void 'the versions stay where they were before the art was coloured'() { From 181ac758a90d90fbc239d822889827a3ea273dfe Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 23:34:36 -0700 Subject: [PATCH 042/115] Address review: metadata only for a native build, and four smaller things Generating the native metadata was wired into processResources, so a build that only wanted to write a resource compiled its sources and resolved its whole runtime classpath first -- which a project that had declared no repositories could not do. Four of the Gradle plugin's own tests failed on it. The metadata is read by nothing but a native image, so it is generated only where one is being built. A tag library the application had already declared was kept but still altered: any existing definition with no autowiring had by-name autowiring put back on it, which cannot tell a generated definition from one an application deliberately declared that way. What a generated definition needs is carried into it while it is generated, so nothing has to be put back afterwards, and an existing definition is now left exactly as it was found. A banner colour given as a number was passed on whatever it was, so -1 or 999 wrote an escape the terminal does not understand and then showed it in the banner. Numbers are held to the 256 a terminal has, and anything else falls back. grails.banner.art.color is documented beside the rest of the banner configuration and declared in the configuration metadata, so an IDE offers it and says what it takes. The Hibernate datastore held its event publisher rather than referencing one, and its connection-source definitions declared what they produce in a way that reads back as a mismatch: a supplier typed for the DataSource that builds the factory bean which produces it. Neither could be expressed as generated code, so a Hibernate application could not be built ahead of time at all -- the first fails generation, the second fails to compile what generation wrote. (cherry picked from commit 4f8c2c99cee33bbf32f0c586349fe31da1a32909) --- .../groovy/grails/boot/GrailsBanner.groovy | 11 +++++- .../beans/aot/BeanRegistrarRuntimeHints.java | 14 ++++++- ...itional-spring-configuration-metadata.json | 38 ++++++++++++++----- .../grails/boot/GrailsBannerColourSpec.groovy | 18 +++++++++ .../aot/BeanRegistrarRuntimeHintsSpec.groovy | 11 ++++++ ...DatastoreConnectionSourcesRegistrar.groovy | 7 ++-- ...HibernateDatastoreSpringInitializer.groovy | 16 +++++++- .../conf/applicationClass/customizing.adoc | 8 ++++ .../plugin/core/GrailsGradlePlugin.groovy | 21 +++++++++- .../TagLibBeanDefinitionsPostProcessor.groovy | 28 ++------------ ...LibBeanDefinitionsPostProcessorSpec.groovy | 25 ++++++------ 11 files changed, 143 insertions(+), 54 deletions(-) diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 3ad9004f1d1..73e5c268a03 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -113,16 +113,23 @@ class GrailsBanner implements Banner { return null } if (configured.isInteger()) { - return Ansi8BitColor.foreground(configured.toInteger()) + int code = configured.toInteger() + // A terminal offers 256 of them, and anything else writes an escape it does not + // understand -- which shows as the escape itself, printed into the banner. + return code in 0..255 ? Ansi8BitColor.foreground(code) : defaultArtColour() } try { return AnsiColor.valueOf(configured.toUpperCase()) } catch (IllegalArgumentException ignored) { - return Ansi8BitColor.foreground(DEFAULT_ART_COLOR.toInteger()) + return defaultArtColour() } } + private AnsiElement defaultArtColour() { + Ansi8BitColor.foreground(DEFAULT_ART_COLOR.toInteger()) + } + /** * Creates the banner art to be displayed. * diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java index 1b7400422c6..48ce66481b9 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java @@ -23,6 +23,9 @@ import org.springframework.aot.hint.RuntimeHintsRegistrar; import org.springframework.beans.factory.BeanRegistrar; import org.springframework.beans.factory.BeanRegistry; +import org.springframework.beans.factory.ListableBeanFactory; +import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; +import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.lang.Nullable; /** @@ -37,6 +40,10 @@ * first call and the context does not start, reporting a method of an interface that appears nowhere * in the application -- a plugin declaring a bean with a specification, which most of them do.

    * + *

    The same is true of the registry the older bean DSL is handed: a plugin that still declares + * its beans that way asks whether one is already registered, and that call is made the same + * reflective way. It failed later than the others, once a datastore came to be configured.

    + * *

    The types are named here rather than scanned for, because they belong to Spring and are few.

    * * @since 8.0 @@ -48,7 +55,12 @@ public class BeanRegistrarRuntimeHints implements RuntimeHintsRegistrar { BeanRegistrar.class, BeanRegistry.class, BeanRegistry.Spec.class, - BeanRegistry.SupplierContext.class + BeanRegistry.SupplierContext.class, + // The registry the older bean DSL is handed, which the plugins that still use it call the + // same way: asking whether a bean is already there, registering one, naming an alias. + BeanDefinitionRegistry.class, + ListableBeanFactory.class, + ConfigurableListableBeanFactory.class }; @Override diff --git a/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json index ec339dce9a7..9ceecec922d 100644 --- a/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -2,15 +2,21 @@ "properties": [ { "name": "grails.banner.art.display", - "description": "Whether to display the Grails banner art.", + "description": "Whether to display the Grails banner art.", "type": "java.lang.Boolean", "defaultValue": true }, { - "name": "grails.banner.art.file", - "description": "The file path on the classpath to the Grails banner art to display.", - "type": "java.lang.String", - "defaultValue": "grails-banner.txt" + "name": "grails.banner.art.file", + "description": "The file path on the classpath to the Grails banner art to display.", + "type": "java.lang.String", + "defaultValue": "grails-banner.txt" + }, + { + "name": "grails.banner.art.color", + "type": "java.lang.String", + "description": "The colour to show the banner art in, where the terminal colours output at all. A number selects one of the 256 colours a terminal offers; a name selects one of the eight it has always had, such as red or bright_blue; none leaves the art uncoloured. A value that is neither falls back to the default.", + "defaultValue": "214" }, { "name": "grails.banner.versions.display", @@ -56,11 +62,23 @@ { "name": "grails.i18n.localeResolver", "values": [ - { "value": "session", "description": "Resolve the locale from the HTTP session (mutable; ?lang= switching works). The default." }, - { "value": "cookie", "description": "Resolve the locale from a cookie (mutable; ?lang= switching works)." }, - { "value": "acceptHeader", "description": "Resolve the locale from the Accept-Language header (read-only; ?lang= is ignored)." }, - { "value": "fixed", "description": "Use a fixed locale from grails.i18n.default.locale, falling back to the JVM default (read-only; ?lang= is ignored)." } + { + "value": "session", + "description": "Resolve the locale from the HTTP session (mutable; ?lang= switching works). The default." + }, + { + "value": "cookie", + "description": "Resolve the locale from a cookie (mutable; ?lang= switching works)." + }, + { + "value": "acceptHeader", + "description": "Resolve the locale from the Accept-Language header (read-only; ?lang= is ignored)." + }, + { + "value": "fixed", + "description": "Use a fixed locale from grails.i18n.default.locale, falling back to the JVM default (read-only; ?lang= is ignored)." + } ] } ] -} \ No newline at end of file +} diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy index a7610849731..13321c4ae2c 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerColourSpec.groovy @@ -109,6 +109,24 @@ class GrailsBannerColourSpec extends Specification { .startsWith(AnsiOutput.encode(Ansi8BitColor.foreground(214))) } + void 'a number outside the 256 a terminal has falls back'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + + expect: 'anything else writes an escape the terminal does not understand, which it then shows' + banner.colour('art', configuredWith('999')) + .startsWith(AnsiOutput.encode(Ansi8BitColor.foreground(214))) + banner.colour('art', configuredWith('-1')) + .startsWith(AnsiOutput.encode(Ansi8BitColor.foreground(214))) + } + + /** A fresh environment each time, so the two values above do not fight over one property source. */ + private StandardEnvironment configuredWith(String colour) { + StandardEnvironment fresh = new StandardEnvironment() + fresh.propertySources.addFirst(new MapPropertySource('test', ['grails.banner.art.color': colour])) + fresh + } + void 'the banner carries the colour through to what is printed'() { given: AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy index 86af0cf6600..e0204de73ca 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy @@ -26,6 +26,9 @@ import org.springframework.aot.hint.TypeHint import org.springframework.aot.hint.TypeReference import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.BeanRegistry +import org.springframework.beans.factory.ListableBeanFactory +import org.springframework.beans.factory.config.ConfigurableListableBeanFactory +import org.springframework.beans.factory.support.BeanDefinitionRegistry import spock.lang.Specification /** @@ -63,6 +66,14 @@ class BeanRegistrarRuntimeHintsSpec extends Specification { hintFor(BeanRegistrar)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) } + void 'the registry the older bean DSL is handed can be called'() { + expect: 'a plugin that still declares its beans that way asks whether one is already there' + hintFor(BeanDefinitionRegistry)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + hintFor(ListableBeanFactory)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + hintFor(ConfigurableListableBeanFactory)?.memberCategories + ?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + void 'the call a plugin actually makes is covered'() { given: 'the three-argument form, which is what a bean with a specification uses' def registerBean = BeanRegistry.getMethod('registerBean', String, Class, Consumer) diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrar.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrar.groovy index 231da37c875..495b1c9367e 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrar.groovy +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrar.groovy @@ -31,6 +31,7 @@ import org.springframework.beans.factory.config.ConstructorArgumentValues import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor import org.springframework.beans.factory.support.RootBeanDefinition +import org.springframework.core.ResolvableType import org.springframework.core.Ordered import org.springframework.transaction.PlatformTransactionManager @@ -63,7 +64,7 @@ class HibernateDatastoreConnectionSourcesRegistrar implements BeanDefinitionRegi if (!registry.containsBeanDefinition(dataSourceBeanName) && shouldConfigureDataSourceBean) { def dataSourceBean = new RootBeanDefinition() - dataSourceBean.setTargetType(DataSource) + dataSourceBean.setTargetType(ResolvableType.forClassWithGenerics(InstanceFactoryBean, DataSource)) dataSourceBean.setBeanClass(InstanceFactoryBean) def args = new ConstructorArgumentValues() String spel = "#{dataSourceConnectionSourceFactory.create('$dataSourceName', environment).source}".toString() @@ -80,7 +81,7 @@ class HibernateDatastoreConnectionSourcesRegistrar implements BeanDefinitionRegi String transactionManagerBeanName = "transactionManager$suffix" def sessionFactoryBean = new RootBeanDefinition() - sessionFactoryBean.setTargetType(SessionFactory) + sessionFactoryBean.setTargetType(ResolvableType.forClassWithGenerics(InstanceFactoryBean, SessionFactory)) sessionFactoryBean.setBeanClass(InstanceFactoryBean) def args = new ConstructorArgumentValues() args.addGenericArgumentValue("#{hibernateDatastore.getDatastoreForConnection('$dataSourceName').sessionFactory}".toString()) @@ -93,7 +94,7 @@ class HibernateDatastoreConnectionSourcesRegistrar implements BeanDefinitionRegi ) def transactionManagerBean = new RootBeanDefinition() - transactionManagerBean.setTargetType(PlatformTransactionManager) + transactionManagerBean.setTargetType(ResolvableType.forClassWithGenerics(InstanceFactoryBean, PlatformTransactionManager)) transactionManagerBean.setBeanClass(InstanceFactoryBean) def txMgrArgs = new ConstructorArgumentValues() txMgrArgs.addGenericArgumentValue("#{hibernateDatastore.getDatastoreForConnection('$dataSourceName').transactionManager}".toString()) diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy b/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy index bcd83fd0f9e..2be5b60d9d3 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy @@ -22,11 +22,14 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry import grails.spring.BeanBuilder import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationEventPublisher +import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.support.GenericApplicationContext import org.springframework.core.env.ConfigurableEnvironment import org.springframework.core.env.PropertyResolver import org.springframework.transaction.PlatformTransactionManager +import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher +import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher import org.grails.datastore.gorm.bootstrap.AbstractDatastoreInitializer import org.grails.datastore.gorm.jdbc.connections.CachedDataSourceConnectionSourceFactory import org.grails.datastore.gorm.support.AbstractDatastorePersistenceContextInterceptor @@ -168,6 +171,17 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { Object configurationReference = configurationReference(beanDefinitionRegistry) final boolean isGrailsPresent = isGrailsPresent() def appContext = this.applicationContext + // Registered rather than built here, so what the datastore holds is a reference the + // container can build. Holding the publisher itself puts a live object in the + // definition, and generating code for a definition means writing out what it holds -- + // which a publisher bound to a running context is not. + if (beanDefinitionRegistry instanceof ConfigurableApplicationContext + || resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext) { + grailsDatastoreEventPublisher(ConfigurableApplicationContextEventPublisher) + } + else { + grailsDatastoreEventPublisher(DefaultApplicationEventPublisher) + } dataSourceConnectionSourceFactory(CachedDataSourceConnectionSourceFactory) hibernateConnectionSourceFactory(HibernateConnectionSourceFactory, ref('hibernateBytecodeProvider'), persistentClasses as Class[]) { bean -> bean.autowire = true @@ -176,7 +190,7 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { applicationContext = appContext } } - hibernateDatastore(HibernateDatastore, configurationReference, hibernateConnectionSourceFactory, eventPublisher) { bean -> + hibernateDatastore(HibernateDatastore, configurationReference, hibernateConnectionSourceFactory, ref('grailsDatastoreEventPublisher')) { bean -> bean.primary = true } sessionFactory(hibernateDatastore: 'getSessionFactory') { bean -> diff --git a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc index 246639c6a62..359444fb1e0 100644 --- a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc +++ b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc @@ -93,6 +93,14 @@ grails: art: display: true # Whether to display the banner art (default: true). file: 'banner.txt' # Path to a custom banner file on the classpath (default: null). + # The colour to show the art in, where the terminal colours output at all (default: 214). + # A number selects one of the 256 colours a terminal offers; a name selects one of the + # eight it has always had; 'none' leaves the art uncoloured. A value that is neither + # falls back to the default. Named colours are: + # black, red, green, yellow, blue, magenta, cyan, white + # bright_black, bright_red, bright_green, bright_yellow, + # bright_blue, bright_magenta, bright_cyan, bright_white + color: 214 versions: display: true # Whether to display version information (default: true). include: diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index d5223b25c52..df4f7f78c0d 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -84,6 +84,8 @@ import javax.inject.Inject */ @CompileStatic class GrailsGradlePlugin implements Plugin { + private static final String NATIVE_IMAGE_PLUGIN = 'org.graalvm.buildtools.native' + private static final String CLI_PID_FILE_PROPERTY = 'grails.cli.pid.file' private static final String RUN_APP_PID_FILE_NAME = 'run-app.pid' @@ -1124,6 +1126,17 @@ ${importStatements} * output already names both, so an application does not have to be traced to be buildable. */ protected void configureNativeMetadata(Project project) { + // Only where an image is actually being built. The metadata is read by nothing else, and + // generating it means reading the compiled classes and the pages compiled into every + // dependency -- so wiring it into processResources unconditionally made a build that only + // wanted to write a resource compile its sources and resolve its whole runtime classpath + // first, which a project that had declared no repositories could not do. + project.pluginManager.withPlugin(NATIVE_IMAGE_PLUGIN) { + configureNativeMetadataTask(project) + } + } + + private void configureNativeMetadataTask(Project project) { SourceSet sourceSet = SourceSets.findMainSourceSet(project) TaskProvider metadataTask = project.tasks.register( @@ -1141,7 +1154,13 @@ ${importStatements} } task.classesDirs.from(sourceSet.output.classesDirs) task.pageClassesDirs.from(project.layout.buildDirectory.dir('gsp-classes/main')) - task.pageClasspath.from(project.configurations.named('runtimeClasspath')) + // Leniently: the pages compiled into dependencies are worth finding, but not at the + // price of making every build that writes a resource resolve the whole runtime + // classpath first. A dependency that cannot be resolved contributes no pages rather + // than failing a build that never asked for a native image. + task.pageClasspath.from(project.configurations.named('runtimeClasspath').map { conf -> + conf.incoming.artifactView { view -> view.lenient(true) }.files + }) task.outputDirectory.set(project.layout.buildDirectory.dir('generated-resources/grails-native')) } diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy index 7c7f3268c0e..111f436141e 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy @@ -21,7 +21,6 @@ package org.grails.plugins.web import groovy.transform.CompileStatic import groovy.util.logging.Slf4j -import org.springframework.beans.factory.config.BeanDefinition import org.springframework.beans.factory.config.ConfigurableListableBeanFactory import org.springframework.beans.factory.support.AbstractBeanDefinition import org.springframework.beans.factory.support.BeanDefinitionRegistry @@ -47,8 +46,10 @@ import org.grails.core.artefact.gsp.TagLibArtefactHandler * *

    The artefacts are read from the application rather than named individually, so a tag library * belongs to whoever declared it: the application, another plugin, or one supplied through - * {@code providedArtefacts}. An existing definition for the same name wins, which preserves the - * ability to override a tag library.

    + * {@code providedArtefacts}. An existing definition for the same name wins untouched, which + * preserves the ability to override a tag library -- including one deliberately declared without + * by-name autowiring, which cannot be told apart from a generated one. What a generated definition + * needs is carried into it while it is generated, by the processor that reads the autowire mode.

    * * @since 8.0 */ @@ -71,7 +72,6 @@ class TagLibBeanDefinitionsPostProcessor implements BeanDefinitionRegistryPostPr continue } if (registry.containsBeanDefinition(beanName)) { - restoreAutowiringByName(registry.getBeanDefinition(beanName), beanName) continue } GenericBeanDefinition definition = new GenericBeanDefinition( @@ -84,26 +84,6 @@ class TagLibBeanDefinitionsPostProcessor implements BeanDefinitionRegistryPostPr } } - /** - * Restores by-name autowiring on a definition that already exists. - * - *

    A tag library takes some of its collaborators by name rather than by annotation, and - * ahead-of-time processing does not carry that over: it generates the injection it can see from - * the annotations and leaves the mode at none, so a message source or an asset resolver arrives - * null. The mode is only ever raised, never lowered, so a definition that asks for something - * else keeps it.

    - */ - private void restoreAutowiringByName(BeanDefinition existing, String beanName) { - if (!(existing instanceof AbstractBeanDefinition)) { - return - } - AbstractBeanDefinition definition = (AbstractBeanDefinition) existing - if (definition.autowireMode == AbstractBeanDefinition.AUTOWIRE_NO) { - definition.autowireMode = AbstractBeanDefinition.AUTOWIRE_BY_NAME - log.debug('Restored autowiring by name on tag library {}', beanName) - } - } - @Override void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { } diff --git a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy index ff1d63b8d07..591e36bc703 100644 --- a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy +++ b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy @@ -80,30 +80,31 @@ class TagLibBeanDefinitionsPostProcessorSpec extends Specification { registry.getBeanDefinition(DemoTagLib.name).is(generated) } - void 'autowiring by name is restored on a definition that lost it'() { - given: 'the generator does not write the mode out, so it arrives as none' - RootBeanDefinition generated = new RootBeanDefinition(DemoTagLib) - generated.autowireMode = AbstractBeanDefinition.AUTOWIRE_NO - registry.registerBeanDefinition(DemoTagLib.name, generated) + void 'a definition that declares no autowiring is left declaring none'() { + given: 'an application that deliberately took by-name autowiring off its own tag library' + RootBeanDefinition declared = new RootBeanDefinition(DemoTagLib) + declared.autowireMode = AbstractBeanDefinition.AUTOWIRE_NO + registry.registerBeanDefinition(DemoTagLib.name, declared) when: process() - then: - generated.autowireMode == AbstractBeanDefinition.AUTOWIRE_BY_NAME + then: 'which cannot be told apart from a generated one, so neither is touched -- what a ' + + 'generated definition needs is carried into it while it is generated' + declared.autowireMode == AbstractBeanDefinition.AUTOWIRE_NO } void 'a definition asking for something else keeps it'() { given: - RootBeanDefinition generated = new RootBeanDefinition(DemoTagLib) - generated.autowireMode = AbstractBeanDefinition.AUTOWIRE_BY_TYPE - registry.registerBeanDefinition(DemoTagLib.name, generated) + RootBeanDefinition declared = new RootBeanDefinition(DemoTagLib) + declared.autowireMode = AbstractBeanDefinition.AUTOWIRE_BY_TYPE + registry.registerBeanDefinition(DemoTagLib.name, declared) when: process() - then: 'the mode is only ever raised, never lowered' - generated.autowireMode == AbstractBeanDefinition.AUTOWIRE_BY_TYPE + then: + declared.autowireMode == AbstractBeanDefinition.AUTOWIRE_BY_TYPE } /** Recognised as a tag library by its name, which is what the artefact handler reads. */ From 7687f84639d9db222bcbe20bb781bafb538bb857 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 23:42:29 -0700 Subject: [PATCH 043/115] Leave a datastore's proxy handler alone The core plugin registers a proxy handler for an application that has none, and these registrars run after the doWithSpring drain -- so it was registered over the one a GORM implementation had already declared, which is the one that knows how to unwrap that datastore's proxies. A Hibernate application was left unwrapping Hibernate proxies with the general case, and said so on every start by reporting proxyHandler as an overridden definition. It is registered only where nothing has declared one, the way the resource locator already backs off to the one GSP declares. (cherry picked from commit 2476b1b5b012964f817e34c30dca672c0984aea2) --- .../grails/plugins/CoreGrailsPlugin.groovy | 21 +++++++++++++--- .../plugins/CoreGrailsPluginAotSpec.groovy | 24 +++++++++++++++++++ 2 files changed, 42 insertions(+), 3 deletions(-) diff --git a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy index 7cbdfedf6eb..bb7668aa486 100644 --- a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy +++ b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy @@ -131,10 +131,20 @@ class CoreGrailsPlugin extends Plugin { * none, and is what the plugin's own processor is for.

    */ private static boolean hasConfigurationClassPostProcessor(GrailsApplication application) { + hasBeanDefinition(application, AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME) + } + + /** + * Whether the context already has a definition under this name. + * + *

    These registrars run after the {@code doWithSpring} drain, so a plugin that has already + * declared a bean under one of these names has declared the one that should stand: registering + * over it replaces something chosen for the application with the general case.

    + */ + private static boolean hasBeanDefinition(GrailsApplication application, String beanName) { ApplicationContext context = application.mainContext context instanceof ConfigurableApplicationContext && - ((ConfigurableApplicationContext) context).beanFactory.containsBeanDefinition( - AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME) + ((ConfigurableApplicationContext) context).beanFactory.containsBeanDefinition(beanName) } /** @@ -218,7 +228,12 @@ class CoreGrailsPlugin extends Plugin { } } - registry.registerBean('proxyHandler', DefaultProxyHandler) + // The GORM implementations register a proxy handler that knows how to unwrap their own + // proxies; this is the one for an application that has none. Registering it over theirs + // left a Hibernate application unwrapping Hibernate proxies with the general case. + if (!hasBeanDefinition(application, 'proxyHandler')) { + registry.registerBean('proxyHandler', DefaultProxyHandler) + } // an abstract parent definition, which registerBean cannot express since it always // takes a class; third-party plugins inherit their search locations from it diff --git a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy index 8c1d98f2c74..32395f089a5 100644 --- a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy @@ -25,6 +25,7 @@ import org.springframework.aot.generate.InMemoryGeneratedFiles import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.support.BeanRegistryAdapter import org.springframework.beans.factory.support.GenericBeanDefinition +import org.springframework.beans.factory.support.RootBeanDefinition import org.springframework.context.annotation.AnnotationConfigUtils import org.springframework.context.aot.ApplicationContextAotGenerator import org.springframework.context.support.GenericApplicationContext @@ -118,6 +119,29 @@ class CoreGrailsPluginAotSpec extends Specification { context.containsBeanDefinition(AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME) } + void "a datastore's own proxy handler is not replaced"() { + given: 'what a GORM implementation declares from doWithSpring, which runs earlier' + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + context.registerBeanDefinition('proxyHandler', new RootBeanDefinition(String)) + + when: + applyCorePluginRegistrar() + + then: 'it knows how to unwrap that datastore\'s proxies, and this one does not' + context.getBeanDefinition('proxyHandler').beanClassName == String.name + } + + void 'the proxy handler is registered where no datastore declared one'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + + when: + applyCorePluginRegistrar() + + then: + context.containsBeanDefinition('proxyHandler') + } + void 'the core plugin bean definitions can be generated ahead of time'() { given: SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') From 813e1918da17f38fd61868a6984057426deb4447 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 6 Aug 2026 23:50:36 -0700 Subject: [PATCH 044/115] Let an image call the framework's own interfaces A plugin descriptor is Groovy written largely without static compilation, so reading a setting, asking the application about its artefacts, or asking the plugin manager about a plugin are all resolved where the call is written rather than when the descriptor is compiled -- and are therefore made reflectively. An image keeps a method for that only when asked, and an application never names these itself: they are the framework's, called from the framework's own descriptors. So the image refused the call and reported a method of an interface appearing nowhere in the application. The one that stopped a context from starting was ConfigMap.getProperty, which is how nearly every plugin reads its settings. Only the interfaces are named. What implements them is reached through them, and registering the implementations would be registering most of the framework. (cherry picked from commit 3d18e3417f543c99aa6d8a056c5fc678d5e5ad7d) --- .../beans/aot/GrailsApiRuntimeHints.java | 70 +++++++++++++++++ .../resources/META-INF/spring/aot.factories | 1 + .../aot/GrailsApiRuntimeHintsSpec.groovy | 77 +++++++++++++++++++ 3 files changed, 148 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java new file mode 100644 index 00000000000..517f21a6e57 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java @@ -0,0 +1,70 @@ +/* + * 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.grails.spring.beans.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +import grails.config.Config; +import grails.config.ConfigMap; +import grails.core.GrailsApplication; +import grails.core.GrailsClass; +import grails.plugins.GrailsPlugin; +import grails.plugins.GrailsPluginManager; + +/** + * Registers the framework's own interfaces, which a plugin reaches through dynamically. + * + *

    A plugin descriptor is Groovy, and much of it is written without static compilation -- so + * reading a configuration value, asking the application for its artefacts, or asking the plugin + * manager about a plugin are all calls resolved where they are written rather than when the + * descriptor is compiled. Each is therefore made reflectively.

    + * + *

    An image keeps a method for that only when something has asked it to, and an application never + * names these itself: they are the framework's, called from the framework's own descriptors. The + * image refuses the call where it is made, and what it reports is a method of an interface that + * appears nowhere in the application -- the last of them stopping a context from starting on + * {@code ConfigMap.getProperty}, which is how nearly every plugin reads its settings.

    + * + *

    Only the interfaces are named. What implements them is reached through them, and registering + * the implementations would be registering most of the framework.

    + * + * @since 8.0 + */ +public class GrailsApiRuntimeHints implements RuntimeHintsRegistrar { + + /** What a descriptor written without static compilation calls on the framework. */ + private static final Class[] TYPES = { + Config.class, + ConfigMap.class, + GrailsApplication.class, + GrailsClass.class, + GrailsPlugin.class, + GrailsPluginManager.class + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (Class type : TYPES) { + hints.reflection().registerType(type, MemberCategory.INVOKE_DECLARED_METHODS); + } + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index f263d9e0f9d..c43038d0e7c 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -3,6 +3,7 @@ org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter org.springframework.aot.hint.RuntimeHintsRegistrar=\ org.grails.spring.beans.aot.BeanRegistrarRuntimeHints,\ +org.grails.spring.beans.aot.GrailsApiRuntimeHints,\ org.grails.spring.beans.aot.GrailsClosureRuntimeHints,\ org.grails.spring.beans.aot.GroovyExtensionModuleRuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..ac42935e71d --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy @@ -0,0 +1,77 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +import grails.config.Config +import grails.config.ConfigMap +import grails.core.GrailsApplication +import grails.plugins.GrailsPluginManager + +/** + * Covers the framework's own interfaces being callable from an image. + * + *

    A plugin descriptor is Groovy written largely without static compilation, so reading a setting + * or asking the application about its artefacts is resolved where the call is written and made + * reflectively. An application never names these interfaces itself, so nothing else asks an image to + * keep them, and a context stopped starting on ConfigMap.getProperty -- how nearly every plugin + * reads its settings.

    + */ +class GrailsApiRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new GrailsApiRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private boolean invocable(Class type) { + def hint = hints.reflection().getTypeHint(TypeReference.of(type)) + hint != null && hint.memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the configuration a plugin reads its settings from can be called'() { + expect: + invocable(ConfigMap) + invocable(Config) + } + + void 'what a plugin asks about the application can be called'() { + expect: + invocable(GrailsApplication) + } + + void 'what a plugin asks about the plugins can be called'() { + expect: + invocable(GrailsPluginManager) + } + + void 'the call that stopped a context from starting is covered'() { + given: 'the form a plugin uses to read a setting with a type and a default' + def getProperty = ConfigMap.getMethod('getProperty', String, Class, Object) + + expect: + getProperty.declaringClass == ConfigMap + invocable(ConfigMap) + } +} From 7a063e3a986bb30bab7fbfba19f17e0e8cf5a458 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 00:00:25 -0700 Subject: [PATCH 045/115] Skip a closure whose surroundings cannot be loaded A closure loads without the class it was written inside -- it extends Closure and nothing else -- so asking only whether the closure loads lets one through whose surroundings are absent. Registering it makes the image analyse it, and analysing a closure means reading the method it was written in. The Hibernate plugin ships a Spock specification for applications to write their tests against, and ships it in its main jar, so it is on the runtime classpath of every application that uses Hibernate whether or not that application tests with Spock. One that does not has no spock.lang.Specification for the image to read, and the build failed on a class the application never asked for: Error encountered while parsing grails.test.hibernate.HibernateSpec$_setupSpec_closure5 Caused by: NoClassDefFoundError: spock/lang/Specification The class the closure was written inside now has to load as well. The test asks the guard directly. A class loader that hides Spock does not reproduce this, because loading the enclosing class delegates to a parent that can still see it -- which is worth knowing, since such a test passes while proving nothing. (cherry picked from commit 7d63e65b7aeb390e58aeb60b9fafd2305e6bb5fc) --- .../beans/aot/GrailsClosureRuntimeHints.java | 20 ++++++++++++++++++- .../aot/GrailsClosureRuntimeHintsSpec.groovy | 16 +++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java index 55881d9f1f0..b47e925d585 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -114,7 +114,7 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) * a method body. */ private boolean registrable(String className, Resource resource, ClassLoader loader) { - if (!RegistrableTypes.loads(className, loader)) { + if (!RegistrableTypes.loads(className, loader) || !enclosingLoads(className, loader)) { return false; } try { @@ -125,6 +125,24 @@ private boolean registrable(String className, Resource resource, ClassLoader loa } } + /** + * Whether the class the closure was written inside can be loaded. + * + *

    A closure loads without it -- it extends {@code Closure} and nothing else -- so asking only + * about the closure lets one through whose surroundings are absent. Registering it makes the + * image analyse it, and analysing a closure means reading the method it was written in: the test + * support ships closures written inside a Spock specification, and an application that does not + * test with Spock has no {@code spock.lang.Specification} for the image to read, which fails the + * build rather than the closure.

    + */ + boolean enclosingLoads(String className, ClassLoader loader) { + int closure = className.indexOf("$_"); + if (closure < 0) { + return true; + } + return RegistrableTypes.loads(className.substring(0, closure), loader); + } + @Nullable private String classNameOf(MetadataReaderFactory factory, Resource resource) { try { diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy index 64ed1b98f80..c489ed120d7 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy @@ -75,6 +75,22 @@ class GrailsClosureRuntimeHintsSpec extends Specification { RuntimeHintsPredicates.resource().forResource('META-INF/grails.factories').test(hints) } + void 'a closure is skipped when the class it was written inside cannot be loaded'() { + given: + def registrar = new GrailsClosureRuntimeHints() + ClassLoader loader = getClass().classLoader + + expect: 'analysing a closure means reading the method it was written in, so a closure whose ' + + 'surroundings are absent fails the build rather than being left out of it' + !registrar.enclosingLoads('com.example.NotHere$_someMethod_closure1', loader) + + and: 'one written inside a class that is present is kept' + registrar.enclosingLoads('org.grails.config.NavigableMap$_flattenKeys_closure3', loader) + + and: 'a class that is not a closure has no surroundings to ask about' + registrar.enclosingLoads('org.grails.config.NavigableMap', loader) + } + void 'a class loader that resolves nothing yields no hints rather than failing'() { when: new GrailsClosureRuntimeHints().registerHints(hints, new URLClassLoader(new URL[0], null)) From 5846c43855a7539e5342717b5466244c4f1ed5e0 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 00:16:16 -0700 Subject: [PATCH 046/115] Let an image call the Spring interfaces a plugin is handed A plugin descriptor is given the environment, the context and the resource loader, and calls them the same dynamic way it calls the framework's own interfaces -- so each call is made reflectively, and an application names none of them either. Reading a setting from the environment stopped a Hibernate application from starting in exactly the way reading one from the configuration stopped every application: PropertyResolver.getProperty, from the datastore initializer. (cherry picked from commit 6a30b0c96aac2dedde0f739d5573a780ebc1cf00) --- .../beans/aot/GrailsApiRuntimeHints.java | 23 +++++++++++++++++-- .../aot/GrailsApiRuntimeHintsSpec.groovy | 11 +++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java index 517f21a6e57..75358b26a91 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java @@ -21,6 +21,12 @@ import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ConfigurableApplicationContext; +import org.springframework.core.env.ConfigurableEnvironment; +import org.springframework.core.env.Environment; +import org.springframework.core.env.PropertyResolver; +import org.springframework.core.io.ResourceLoader; import org.springframework.lang.Nullable; import grails.config.Config; @@ -31,7 +37,8 @@ import grails.plugins.GrailsPluginManager; /** - * Registers the framework's own interfaces, which a plugin reaches through dynamically. + * Registers the interfaces a plugin reaches through dynamically: the framework's own, and the + * Spring ones it is handed. * *

    A plugin descriptor is Groovy, and much of it is written without static compilation -- so * reading a configuration value, asking the application for its artefacts, or asking the plugin @@ -44,6 +51,11 @@ * appears nowhere in the application -- the last of them stopping a context from starting on * {@code ConfigMap.getProperty}, which is how nearly every plugin reads its settings.

    * + *

    The Spring interfaces are here for the same reason rather than a different one: a descriptor is + * given the environment and the context and calls them the same dynamic way, and an application does + * not name them either. Reading a setting from the environment stopped a Hibernate application from + * starting in exactly the way reading one from the configuration stopped every application.

    + * *

    Only the interfaces are named. What implements them is reached through them, and registering * the implementations would be registering most of the framework.

    * @@ -58,7 +70,14 @@ public class GrailsApiRuntimeHints implements RuntimeHintsRegistrar { GrailsApplication.class, GrailsClass.class, GrailsPlugin.class, - GrailsPluginManager.class + GrailsPluginManager.class, + // What a descriptor is handed by Spring and calls the same way + Environment.class, + ConfigurableEnvironment.class, + PropertyResolver.class, + ApplicationContext.class, + ConfigurableApplicationContext.class, + ResourceLoader.class }; @Override diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy index ac42935e71d..2ff8daf8fb1 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy @@ -23,6 +23,10 @@ import org.springframework.aot.hint.RuntimeHints import org.springframework.aot.hint.TypeReference import spock.lang.Specification +import org.springframework.context.ApplicationContext +import org.springframework.core.env.Environment +import org.springframework.core.env.PropertyResolver + import grails.config.Config import grails.config.ConfigMap import grails.core.GrailsApplication @@ -66,6 +70,13 @@ class GrailsApiRuntimeHintsSpec extends Specification { invocable(GrailsPluginManager) } + void 'what Spring hands a plugin can be called'() { + expect: 'a descriptor is given these and calls them the same dynamic way' + invocable(PropertyResolver) + invocable(Environment) + invocable(ApplicationContext) + } + void 'the call that stopped a context from starting is covered'() { given: 'the form a plugin uses to read a setting with a type and a default' def getProperty = ConfigMap.getMethod('getProperty', String, Class, Object) From ac091ad8a9a305396868ee14720229a26f534444 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 00:52:22 -0700 Subject: [PATCH 047/115] Use plain map-entry spacing in the native metadata task The aligned colons were a style violation, and nothing reads the file in a way the alignment helped. (cherry picked from commit 28c32101e9ac0dd61e91bd0483972b4db3422e65) --- .../gradle/plugin/aot/GenerateNativeMetadataTask.groovy | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy index 9174be9b393..c7bb024106b 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy @@ -88,10 +88,10 @@ abstract class GenerateNativeMetadataTask extends DefaultTask { List> reflection = types.sort().collect { String type -> [ - type : type, - allDeclaredMethods : true, - allDeclaredFields : true, - allDeclaredConstructors : true + type: type, + allDeclaredMethods: true, + allDeclaredFields: true, + allDeclaredConstructors: true ] as Map } From da9dcd733c9c77794b4f420901a22b9b4678aed7 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 00:52:23 -0700 Subject: [PATCH 048/115] Train a JDK AOT cache from a run of the application Spring's AOT processing removes the work of deciding what the beans are, which turns out to be the smaller half. What remains is loading and linking the classes and interpreting the methods until they compile, and JDK 25 can record a run of an application and read that record back on the next start instead of doing it again. An application asks for it and says which of its pages matter: grails { aotCache { enabled = true paths = ['/', '/login', '/book/index'] } } That extracts the executable jar -- a cache is only usable against the layout it was trained on, and a nested-jar classloader is not one -- runs what it extracted, asks for each path, and stops it. Startup falls from 2.5s to 1.0s on an application with GORM, security and asset pipeline; asking for paths does not move startup further, but halves the first hit of a cold path. The cache is written as the training JVM exits, so a run that never started leaves nothing behind. That fails the build rather than shipping an application whose cache is silently absent: a JVM given a cache it cannot use declines it and starts as it would have anyway, so the only symptom of a missing or stale cache is the speed it was built for not being there. Beside the cache goes aot-cache.properties, recording the JDK build, the archive digest and the arguments it was trained with, so a deployment can tell whether the cache it has still applies before it finds out by being slow. (cherry picked from commit 743206bd2b07bfd40af58cc8462f8658a334edd3) --- .../plugin/aot/AotCacheExtension.groovy | 67 ++++++ .../plugin/aot/TrainAotCacheTask.groovy | 216 ++++++++++++++++++ .../plugin/core/GrailsGradlePlugin.groovy | 81 ++++++- .../plugin/aot/TrainAotCacheTaskSpec.groovy | 89 ++++++++ 4 files changed, 452 insertions(+), 1 deletion(-) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy new file mode 100644 index 00000000000..c35a271a99e --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy @@ -0,0 +1,67 @@ +/* + * 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.grails.gradle.plugin.aot + +import groovy.transform.CompileStatic +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property + +/** + * What an application says about the cache the JDK writes for it. + * + *

    A cache makes the next start fast at whatever the training run did, so the only thing an + * application really has to say is which of its pages matter. The rest has an answer that is right + * far more often than not.

    + * + * 
    + * grails {
+ *     aotCache {
+ *         enabled = true
+ *         paths = ['/', '/login', '/user/index']
+ *     }
+ * }
+ *
    + * + * @since 8.0 + */ +@CompileStatic +abstract class AotCacheExtension { + + /** Off unless asked for: training runs the application, which is not part of an ordinary build. */ + abstract Property getEnabled() + + /** + * The paths asked for while training. Empty trains the start alone, which is what + * {@code spring.context.exit=onRefresh} records and is worth having on its own -- but leaves + * every request path to be worked out on the day. + */ + abstract ListProperty getPaths() + + /** + * Given to the training run, and to be given to every run that reads the cache. A cache records + * what it saw, so a run configured differently from the training run reads a cache of a + * different application. + */ + abstract ListProperty getJvmArguments() + + /** Where the training run listens. Not the port the application is deployed on. */ + abstract Property getPort() + + abstract Property getStartTimeoutSeconds() +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy new file mode 100644 index 00000000000..7f34027c1ea --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -0,0 +1,216 @@ +/* + * 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.grails.gradle.plugin.aot + +import java.security.MessageDigest +import java.time.Duration + +import groovy.transform.CompileStatic +import org.gradle.api.DefaultTask +import org.gradle.api.GradleException +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.file.RegularFileProperty +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputDirectory +import org.gradle.api.tasks.OutputFile +import org.gradle.api.tasks.TaskAction + +/** + * Runs the application once so the JDK can write down what starting it needs. + * + *

    The run is the point. A cache records the classes loaded and linked, and the profiles of the + * methods that ran, so the next start reads them rather than working them out again -- which means + * what the next start is fast at is whatever this run did. A run that only refreshes the + * context leaves every request path to be worked out on the day.

    + * + *

    So the application is started, asked for the pages an application is asked for, and then asked + * to stop. It has to stop of its own accord: the cache is written as the JVM exits, and a run that is + * killed writes nothing.

    + * + * @since 8.0 + */ +@CompileStatic +abstract class TrainAotCacheTask extends DefaultTask { + + /** The extracted application: the cache is only usable against the layout it was trained on. */ + @InputDirectory + abstract DirectoryProperty getApplicationDirectory() + + @Input + abstract Property getArchiveFileName() + + @OutputFile + abstract RegularFileProperty getCacheFile() + + @Input + abstract Property getJavaExecutable() + + /** Given to the training run, and to be given to every run that reads the cache. */ + @Input + abstract ListProperty getJvmArguments() + + /** The paths to ask for, so their methods are profiled rather than met for the first time later. */ + @Input + abstract ListProperty getPaths() + + @Input + abstract Property getPort() + + @Input + abstract Property getStartTimeoutSeconds() + + /** Written beside the cache, so what the cache was made from can be checked before it is used. */ + @OutputFile + abstract RegularFileProperty getMetadataFile() + + @TaskAction + void train() { + File directory = applicationDirectory.get().asFile + File cache = cacheFile.get().asFile + cache.delete() + + List command = [] + command << javaExecutable.get() + command << "-XX:AOTCacheOutput=${cache.absolutePath}".toString() + command.addAll(jvmArguments.get()) + command << '-jar' << archiveFileName.get() + command << "--server.port=${port.get()}".toString() + + File output = new File(temporaryDir, 'training.log') + Process process = new ProcessBuilder(command) + .directory(directory) + .redirectErrorStream(true) + .redirectOutput(output) + .start() + try { + awaitStarted(process, output) + exercise() + } + finally { + stop(process) + } + if (!cache.isFile()) { + throw new GradleException("The training run wrote no cache. What it printed is in ${output}") + } + describe(cache, new File(directory, archiveFileName.get())) + logger.lifecycle('Trained {} ({} MB) over {} paths', + cache.name, (cache.length() / (1024 * 1024)) as long, paths.get().size()) + } + + /** + * Writes down what the cache was made from. + * + *

    A cache is read only by the JDK build that wrote it, against the archive it was trained on, + * with the arguments it was trained with. A JVM given one made from anything else declines it and + * starts as it would have anyway -- so what is lost is the speed, silently, and this is what + * tells a deployment which of those it has.

    + */ + private void describe(File cache, File archive) { + Properties properties = new Properties() + properties.setProperty('cache.file', cache.name) + properties.setProperty('cache.bytes', String.valueOf(cache.length())) + properties.setProperty('application.archive', archive.name) + properties.setProperty('application.sha256', sha256(archive)) + properties.setProperty('training.arguments', jvmArguments.get().join(' ')) + properties.setProperty('training.paths', paths.get().join(' ')) + properties.setProperty('java.vendor', System.getProperty('java.vendor', '')) + properties.setProperty('java.runtime.version', System.getProperty('java.runtime.version', '')) + properties.setProperty('java.vm.version', System.getProperty('java.vm.version', '')) + properties.setProperty('os.name', System.getProperty('os.name', '')) + properties.setProperty('os.arch', System.getProperty('os.arch', '')) + metadataFile.get().asFile.withOutputStream { OutputStream out -> + properties.store(out, 'What this AOT cache was trained from') + } + } + + private static String sha256(File file) { + MessageDigest digest = MessageDigest.getInstance('SHA-256') + file.withInputStream { InputStream input -> + byte[] buffer = new byte[8192] + int read + while ((read = input.read(buffer)) != -1) { + digest.update(buffer, 0, read) + } + } + digest.digest().encodeHex().toString() + } + + /** + * Waits for the application to say it has started, and stops waiting if the run ends first -- + * otherwise a run that fails immediately is waited on for the whole timeout. + */ + private void awaitStarted(Process process, File output) { + long deadline = System.currentTimeMillis() + Duration.ofSeconds(startTimeoutSeconds.get()).toMillis() + while (System.currentTimeMillis() < deadline) { + if (!process.isAlive()) { + throw new GradleException('The training run ended before it started serving. ' + + "What it printed is in ${output}") + } + if (output.isFile() && output.text.contains('Started ')) { + return + } + Thread.sleep(250L) + } + throw new GradleException("The training run did not start within ${startTimeoutSeconds.get()}s. " + + "What it printed is in ${output}") + } + + /** + * Asks for each path. A path that answers with an error still profiled the code that produced + * the error, which is code an application runs too, so nothing here fails the build: the run is + * a recording, not a test. + */ + private void exercise() { + for (String path : paths.get()) { + try { + URI uri = URI.create("http://localhost:${port.get()}${path}") + HttpURLConnection connection = (HttpURLConnection) uri.toURL().openConnection() + connection.requestMethod = 'GET' + connection.instanceFollowRedirects = true + connection.connectTimeout = 10_000 + connection.readTimeout = 30_000 + connection.setRequestProperty('Accept', 'text/html,*/*') + int status = connection.responseCode + InputStream body = status >= 400 ? connection.errorStream : connection.inputStream + body?.withCloseable { it.bytes } + logger.info('Trained {} -> {}', path, status) + } + catch (IOException e) { + logger.info('Could not reach {} while training: {}', path, e.message) + } + } + } + + /** + * Asks the run to stop and waits for it. The cache is written as the JVM exits, so this waits + * for the exit rather than for the port to close. + */ + private void stop(Process process) { + if (!process.isAlive()) { + return + } + process.destroy() + if (!process.waitFor(120, java.util.concurrent.TimeUnit.SECONDS)) { + process.destroyForcibly() + throw new GradleException('The training run did not stop, so no cache was written') + } + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index df4f7f78c0d..b8cd112181a 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -44,11 +44,15 @@ import org.gradle.api.attributes.Category import org.gradle.api.file.CopySpec import org.gradle.api.file.DuplicatesStrategy import org.gradle.api.file.FileCollection +import org.gradle.api.file.Directory import org.gradle.api.file.RegularFile +import org.gradle.api.plugins.BasePlugin +import org.gradle.api.plugins.ExtensionAware import org.gradle.api.plugins.ExtraPropertiesExtension import org.gradle.api.plugins.GroovyPlugin import org.gradle.api.plugins.JavaPluginExtension import org.gradle.api.provider.Provider +import org.gradle.api.tasks.Exec import org.gradle.api.tasks.AbstractCopyTask import org.gradle.api.tasks.JavaExec import org.gradle.api.tasks.SourceSet @@ -65,8 +69,9 @@ import org.grails.gradle.plugin.commands.GrailsCliGradlePlugin import org.grails.gradle.plugin.exploded.ExplodedCompatibilityRule import org.grails.gradle.plugin.exploded.ExplodedDisambiguationRule import org.grails.gradle.plugin.exploded.GrailsExplodedPlugin -import org.gradle.api.plugins.BasePlugin +import org.grails.gradle.plugin.aot.AotCacheExtension import org.grails.gradle.plugin.aot.GenerateNativeMetadataTask +import org.grails.gradle.plugin.aot.TrainAotCacheTask import org.grails.gradle.plugin.model.GrailsClasspathToolingModelBuilder import org.grails.gradle.plugin.run.FindMainClassTask import org.grails.gradle.plugin.util.SourceSets @@ -84,8 +89,14 @@ import javax.inject.Inject */ @CompileStatic class GrailsGradlePlugin implements Plugin { + private static final String NATIVE_IMAGE_PLUGIN = 'org.graalvm.buildtools.native' + private static final String SPRING_BOOT_PLUGIN = 'org.springframework.boot' + + private static final int TRAINING_PORT = 18080 + + private static final int TRAINING_START_TIMEOUT_SECONDS = 180 private static final String CLI_PID_FILE_PROPERTY = 'grails.cli.pid.file' private static final String RUN_APP_PID_FILE_NAME = 'run-app.pid' @@ -137,6 +148,7 @@ class GrailsGradlePlugin implements Plugin { enableNative2Ascii(project, grailsVersion) configureNativeMetadata(project) + configureAotCache(project) configureTemplateResources(project) @@ -1121,6 +1133,73 @@ ${importStatements} } } + /** + * Wires up the cache the JDK can write for an application, so the next start reads what a + * training run worked out rather than working it out again. + * + *

    Three steps, because the cache is only usable against the layout it was trained on: the + * archive is extracted, the extracted application is run and asked for its pages, and what the + * run recorded is left beside it. An application asks for this with + * {@code grails.aotCache.enabled}, and says which of its pages matter.

    + */ + protected void configureAotCache(Project project) { + AotCacheExtension extension = ((ExtensionAware) project.extensions.getByName('grails')) + .extensions.create('aotCache', AotCacheExtension) + extension.enabled.convention(false) + extension.paths.convention([]) + extension.jvmArguments.convention(['-Dspring.aot.enabled=true', '-Dgrails.env=production']) + extension.port.convention(TRAINING_PORT) + extension.startTimeoutSeconds.convention(TRAINING_START_TIMEOUT_SECONDS) + + project.pluginManager.withPlugin(SPRING_BOOT_PLUGIN) { + TaskProvider bootJar = project.tasks.named('bootJar') + Provider application = project.layout.buildDirectory.dir('aot-cache/application') + + TaskProvider extract = project.tasks.register('extractAotCacheApplication', Exec) { Exec task -> + task.group = BasePlugin.BUILD_GROUP + task.description = 'Extracts the application, which is the form the cache is read against' + task.onlyIf { extension.enabled.get() } + task.dependsOn(bootJar) + task.doFirst { + project.delete(application.get().asFile) + application.get().asFile.mkdirs() + } + task.commandLine(javaExecutable(project), '-Djarmode=tools', '-jar', + archiveOf(bootJar).absolutePath, 'extract', + '--destination', application.get().asFile.absolutePath) + } + + project.tasks.register('trainAotCache', TrainAotCacheTask) { TrainAotCacheTask task -> + task.group = BasePlugin.BUILD_GROUP + task.description = 'Runs the application once so the JDK can write down what starting it needs' + task.onlyIf { extension.enabled.get() } + task.dependsOn(extract) + task.applicationDirectory.set(application) + task.archiveFileName.set(project.provider { archiveOf(bootJar).name }) + task.cacheFile.set(application.map { Directory dir -> + dir.file("${project.name}.aot") + }) + task.metadataFile.set(application.map { Directory dir -> dir.file('aot-cache.properties') }) + task.javaExecutable.set(javaExecutable(project)) + task.jvmArguments.set(extension.jvmArguments) + task.paths.set(extension.paths) + task.port.set(extension.port) + task.startTimeoutSeconds.set(extension.startTimeoutSeconds) + } + } + } + + /** The archive to extract, read when the task runs rather than while the build is configured. */ + private static File archiveOf(TaskProvider bootJar) { + Provider archive = (Provider) bootJar.get().property('archiveFile') + archive.get().asFile + } + + /** The JDK running the build, which is the JDK the cache is tied to. */ + private static String javaExecutable(Project project) { + new File(System.getProperty('java.home'), 'bin/java').absolutePath + } + /** * Records the application's own classes and pages so a native image keeps them usable. The build * output already names both, so an application does not have to be traced to be buildable. diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy new file mode 100644 index 00000000000..a84e589c3e6 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -0,0 +1,89 @@ +/* + * 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.grails.gradle.plugin.aot + +import org.gradle.api.GradleException +import org.gradle.api.Project +import org.gradle.testfixtures.ProjectBuilder +import spock.lang.Specification +import spock.lang.TempDir + +/** + * Covers the run that writes down what starting the application needs. + * + *

    The cache is written as the training JVM exits, so a run that never started, or one that was + * killed, leaves nothing behind -- and a build that carried on regardless would ship an application + * with no cache and no indication that the speed it was built for is absent.

    + */ +class TrainAotCacheTaskSpec extends Specification { + + @TempDir + File temporaryFolder + + Project project = ProjectBuilder.builder().build() + + private TrainAotCacheTask task(String archiveName, List arguments) { + File application = new File(temporaryFolder, 'application') + application.mkdirs() + new File(application, archiveName).text = 'not a real archive' + TrainAotCacheTask task = project.tasks.create('trainAotCache', TrainAotCacheTask) + task.applicationDirectory.set(application) + task.archiveFileName.set(archiveName) + task.cacheFile.set(new File(application, 'demo.aot')) + task.metadataFile.set(new File(application, 'aot-cache.properties')) + task.javaExecutable.set(new File(System.getProperty('java.home'), 'bin/java').absolutePath) + task.jvmArguments.set(arguments) + task.paths.set([]) + task.port.set(18099) + task.startTimeoutSeconds.set(5) + task + } + + void 'a run that never starts serving fails the build'() { + given: 'an archive that is not one, so the run ends immediately' + TrainAotCacheTask task = task('not-an-archive.jar', []) + + when: + task.train() + + then: 'rather than leaving a build to carry on and ship an application with no cache' + GradleException e = thrown() + e.message.contains('ended before it started serving') + } + + void 'what the run printed is where the failure says it is'() { + given: + TrainAotCacheTask task = task('not-an-archive.jar', []) + + when: + task.train() + + then: + GradleException e = thrown() + new File(e.message.replaceAll(/(?s).*is in /, '').trim()).isFile() + } + + void 'the arguments the run is trained with are the ones it is given'() { + given: + TrainAotCacheTask task = task('not-an-archive.jar', ['-Dspring.aot.enabled=true']) + + expect: 'a run configured differently from the training run reads a cache of another application' + task.jvmArguments.get() == ['-Dspring.aot.enabled=true'] + } +} From b2c7f4395d895b80f65f7e248aada0f8f5ea3cb3 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 00:52:33 -0700 Subject: [PATCH 049/115] Document the AOT cache A page under Deployment covering what the cache is, how an application asks for one, what the training run should be asked to do, and why a cache stops applying -- with the measured figures, because the interesting part is which of the two AOT steps actually moves the number. Also warns about the training run being a real run of the application: it connects to whatever the configuration points at, in the environment the cache is for, which is production by default. (cherry picked from commit ea966fdb61706be18ea46383cff52ec77bb0279b) --- .../guide/deployment/deploymentAotCache.adoc | 164 ++++++++++++++++++ grails-doc/src/en/guide/toc.yml | 1 + 2 files changed, 165 insertions(+) create mode 100644 grails-doc/src/en/guide/deployment/deploymentAotCache.adoc diff --git a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc new file mode 100644 index 00000000000..2e63ec05d4b --- /dev/null +++ b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc @@ -0,0 +1,164 @@ +//// +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. +//// + +Spring's AOT processing removes the work of *deciding* what the beans are. What remains is the work the JVM does regardless: loading and linking classes, and interpreting methods until they are compiled. An AOT cache removes most of that as well. + +The JDK can record a run of an application — the classes it loaded and linked, and the profiles of the methods it executed — into a cache file, and read that file on the next start instead of doing the work again. The cache is a JDK feature rather than a framework one, so it applies to the whole application: the framework, Spring, Hibernate, and the application's own classes alike. + +It requires JDK 25 or later. + + +=== Enabling the cache + + +The cache is produced by running the application, so it is off unless asked for. Say which pages matter: + +[source,groovy] +---- +grails { + aotCache { + enabled = true + paths = ['/', '/login', '/book/index', '/book/show/1'] + } +} +---- + +That adds two tasks. `extractAotCacheApplication` unpacks the executable jar into `build/aot-cache/application`, and `trainAotCache` runs what it unpacked, asks for each path, and stops it: + +[source,bash] +---- +./gradlew trainAotCache +---- + +[source] +---- +Trained myapp.aot (167 MB) over 4 paths +---- + +The application is unpacked first because a cache is read against the layout it was trained on. An executable jar loads its dependencies through a nested-jar classloader; the extracted form loads them as ordinary jars on the classpath, and only the second is a layout a cache can be reused against. + + +=== Running with the cache + + +The extracted directory is what is deployed, and the cache is read from beside it: + +[source,bash] +---- +cd build/aot-cache/application +java -XX:AOTCache=myapp.aot -Dspring.aot.enabled=true -Dgrails.env=production -jar myapp.jar +---- + +A JVM given a cache it cannot use does not fail. It reports why, ignores the cache, and starts as it would have anyway — so an invalid cache costs the startup time it was meant to save, silently, and without any other symptom. + + +=== What the training run should do + + +A cache makes the next start fast at whatever the training run did. Training a run that only refreshes the context records the framework starting, and that alone is most of what the startup time is. + +Asking for paths as well does not make startup faster still — the two caches reach the same figure. What it changes is the first request. Each path asked for during training profiles the code that answers it — URL mapping, the controller, GSP rendering, the data access behind it — so the first real request finds that work done rather than doing it itself. On the same application, the first hit of four cold paths cost around 0.95s against a cache trained on refresh alone, and around 0.48s against one trained over those paths. + +So `paths` is worth setting for the pages that matter on a cold start: the ones a load balancer hits first, and the ones a user sees first. An application whose startup time is all that matters can leave it empty and still get most of the benefit. + +A path that answers with an error still profiles the code that produced the error, which is code the application runs too, so nothing here fails the build. The run is a recording, not a test. + +WARNING: The training run is a real run of the application. It executes bootstrap code, connects to whatever the configuration points at, and writes whatever that code writes. Point it at a build-time or throwaway database, never at production. + +It follows that the application has to be able to start in the environment it is trained in, which is production by default — the environment the cache is for. A datasource that only exists in development is not there during training, and the run fails with whatever the application says when it cannot reach its database: + +[source] +---- +The training run ended before it started serving. +What it printed is in build/tmp/trainAotCache/training.log +---- + +The build fails rather than carrying on, because a cache that was never written is indistinguishable at deployment time from one that was. + +Where the defaults are not right, the rest of the run is configurable: + +[source,groovy] +---- +grails { + aotCache { + enabled = true + paths = ['/'] + jvmArguments = ['-Dspring.aot.enabled=true', '-Dgrails.env=production'] + port = 18080 + startTimeoutSeconds = 120 + } +} +---- + +`jvmArguments` is given to the training run *and* has to be given to every run that reads the cache. A cache records what it saw; a run configured differently from the training run is a different application as far as the cache is concerned, and its cache will be declined. + + +=== Knowing whether a cache still applies + + +A cache is read only by the JDK build that wrote it, against the archive it was trained on, with the arguments it was trained with. Any of those changing invalidates it, and the only symptom is that startup is no longer fast. + +So the training run writes `aot-cache.properties` beside the cache, recording what it was made from: + +[source] +---- +cache.file=myapp.aot +cache.bytes=175019584 +application.archive=myapp-0.1.jar +application.sha256=6f1b... +training.arguments=-Dspring.aot.enabled=true -Dgrails.env=production +training.paths=/ /login /book/index /book/show/1 +java.runtime.version=26+30-2422 +java.vm.version=26+30-2422 +os.name=Mac OS X +os.arch=aarch64 +---- + +A deployment can compare those values against the JVM it is about to start and the jar it is about to run, and decide whether it has a cache that applies or one that will be quietly ignored. Because the cache is tied to an exact JDK build, a CI pipeline that produces the cache must publish it alongside the JDK it was produced with, and a base image upgrade invalidates every cache built against the previous one. + + +=== What it is worth + + +Measured on a Grails application with GORM for Hibernate, security and asset pipeline, best of three starts on the same machine and JDK: + +[cols="3,1,2"] +|=== +| Start | Startup | First hit of four cold paths + +| Ordinary +| 3.150s +| + +| Spring AOT +| 2.489s +| + +| Spring AOT with a cache trained on refresh only +| 1.079s +| 0.847s + +| Spring AOT with a cache trained over those paths +| 1.026s +| 0.445s +|=== + +The shape of that is the point. Spring's AOT processing on its own moves less than might be expected, because deciding what the beans are was never most of the cost — loading and linking the classes was, and that is what the cache removes, more than halving startup. The two caches then reach the same startup figure, and differ in what the application is fast at once it is up. + +An AOT cache and a native image solve the same problem differently and are not combined: a native image has no cache to read because it has already done all of this at build time. The cache is what an application gets when it stays on the JVM — including applications a native image cannot yet build, which is most of those using Hibernate. diff --git a/grails-doc/src/en/guide/toc.yml b/grails-doc/src/en/guide/toc.yml index 6132ebf6094..182fca6ce06 100644 --- a/grails-doc/src/en/guide/toc.yml +++ b/grails-doc/src/en/guide/toc.yml @@ -394,5 +394,6 @@ deployment: deploymentContainer: Container Deployment (e.g. Tomcat) deploymentTasks: Deployment Configuration Tasks deploymentAot: Ahead-of-Time Processing + deploymentAotCache: Ahead-of-Time Caching contributing: title: Contributing to Grails From 59e644ba475cc5e4b2e6a30fb3b69d360f2425ab Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 01:28:20 -0700 Subject: [PATCH 050/115] Package compiled assets where an executable jar can read them The asset pipeline puts them at the root of whatever archive is built. That is where a war serves its web content from, so a war is right. An executable jar has no web content: it serves assets by reading them off the classpath, and its classpath is BOOT-INF/classes -- so the same bytes at the same place, in a jar rather than a war, are packaged but unreachable. The page renders and every asset on it is a 404, including the manifest, so the pages do not even ask for the digest names the pipeline produced. Adding them under the classpath directory is what makes them found. Only for bootJar: a war already serves them from the root, and putting them on its classpath as well would ship the same bytes twice. Keyed on the assetCompile task rather than the plugin that registers it -- the asset pipeline's plugin id has changed once already and the task name has not. (cherry picked from commit c027ce77a80973ed9051b3aaa81019995976e97b) --- .../plugin/core/GrailsGradlePlugin.groovy | 38 +++++++++++++++ .../core/AssetClasspathPackagingSpec.groovy | 47 +++++++++++++++++++ .../asset-classpath-packaging/build.gradle | 42 +++++++++++++++++ .../gradle.properties | 2 + .../asset-classpath-packaging/settings.gradle | 1 + 5 files changed, 130 insertions(+) create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/AssetClasspathPackagingSpec.groovy create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/build.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/gradle.properties create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/settings.gradle diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index b8cd112181a..205b712bdff 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -94,6 +94,11 @@ class GrailsGradlePlugin implements Plugin { private static final String SPRING_BOOT_PLUGIN = 'org.springframework.boot' + private static final String ASSET_COMPILE_TASK = 'assetCompile' + + /** Where an executable jar reads its classpath from, and so where assets have to be to be found. */ + private static final String CLASSPATH_ASSETS_PATH = 'BOOT-INF/classes/assets' + private static final int TRAINING_PORT = 18080 private static final int TRAINING_START_TIMEOUT_SECONDS = 180 @@ -854,6 +859,39 @@ ${importStatements} it.destinationDirectory = project.layout.buildDirectory.dir('assetCompile/assets') } } + configureAssetsOnTheClasspath(project) + } + + /** + * Packages the compiled assets where an executable jar can read them. + * + *

    The asset pipeline plugin puts them at the root of whatever archive is built, which is + * where a war serves its web content from and is therefore right for a war. An executable jar + * has no web content: it serves assets by reading them off the classpath, and its classpath is + * {@code BOOT-INF/classes} -- so the same assets, at the same place, in a jar rather than a war, + * are packaged but unreachable, and every asset a page asks for is a 404 while the page itself + * renders. Adding them under the classpath directory is what makes them found.

    + * + *

    Only for {@code bootJar}. A war already serves them from the root, and putting them on its + * classpath as well would ship the same bytes twice.

    + */ + private void configureAssetsOnTheClasspath(Project project) { + project.pluginManager.withPlugin(SPRING_BOOT_PLUGIN) { + // Read after the build script has run, and by the task the pipeline registers rather + // than by the plugin that registers it: the asset pipeline's plugin id has changed + // once already, and the task name has not. + project.afterEvaluate { + Task assetCompile = project.tasks.findByName(ASSET_COMPILE_TASK) + if (assetCompile == null) { + return + } + project.tasks.named('bootJar', AbstractCopyTask).configure { AbstractCopyTask task -> + task.from(assetCompile.outputs.files) { CopySpec spec -> + spec.into(CLASSPATH_ASSETS_PATH) + } + } + } + } } protected void configureForkSettings(Project project, String grailsVersion) { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/AssetClasspathPackagingSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/AssetClasspathPackagingSpec.groovy new file mode 100644 index 00000000000..fc1ca20b2d1 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/AssetClasspathPackagingSpec.groovy @@ -0,0 +1,47 @@ +/* + * 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.grails.gradle.plugin.core + +import org.gradle.testkit.runner.BuildResult + +/** + * Covers compiled assets being readable from an executable jar. + * + *

    The asset pipeline packages them at the root of the archive, which is where a war serves its + * web content from. An executable jar has no web content: assets are read off the classpath, and + * its classpath is {@code BOOT-INF/classes}. The same bytes at the same place, in a jar rather than + * a war, are packaged but unreachable -- the page renders and every asset on it is a 404.

    + */ +class AssetClasspathPackagingSpec extends GradleSpecification { + + void 'compiled assets are packaged where an executable jar reads its classpath'() { + given: + setupTestResourceProject('asset-classpath-packaging') + + when: + BuildResult result = executeTask('inspectAssetPackaging') + + then: + result.output.contains('ON_CLASSPATH=true') + result.output.contains('ON_CLASSPATH_SVG=true') + + and: 'every compiled asset, not a sample of them' + result.output.contains('ASSET_COUNT=2') + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/build.gradle b/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/build.gradle new file mode 100644 index 00000000000..d6c459512a7 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/build.gradle @@ -0,0 +1,42 @@ +// The asset pipeline plugin is not on the test classpath, and this does not need it: the wiring +// under test reacts to the assetCompile task, so a stand-in that produces compiled assets the same +// way exercises the same path. +plugins { + id 'org.apache.grails.gradle.grails-web' +} + +group = 'org.example.test' + +grails { + bom = null + cliAutoProvision = false +} + +springBoot { + mainClass = 'org.example.test.Application' +} + +def compiledAssets = layout.buildDirectory.dir('assets') + +tasks.register('assetCompile') { + outputs.dir(compiledAssets) + doLast { + def dir = compiledAssets.get().asFile + dir.mkdirs() + new File(dir, 'application-d41d8c.css').text = 'body { }' + new File(dir, 'grails-527fa9.svg').text = '' + } +} + +tasks.register('inspectAssetPackaging') { + dependsOn 'bootJar' + doLast { + def archive = tasks.named('bootJar', Jar).get().archiveFile.get().asFile + def entries = new java.util.zip.ZipFile(archive).withCloseable { zip -> + zip.entries().findAll { !it.directory }.collect { it.name } as Set + } + println "ON_CLASSPATH=${entries.contains('BOOT-INF/classes/assets/application-d41d8c.css')}" + println "ON_CLASSPATH_SVG=${entries.contains('BOOT-INF/classes/assets/grails-527fa9.svg')}" + println "ASSET_COUNT=${entries.count { it.startsWith('BOOT-INF/classes/assets/') }}" + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/gradle.properties b/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/gradle.properties new file mode 100644 index 00000000000..52f4d78c7c2 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/gradle.properties @@ -0,0 +1,2 @@ +grailsVersion=__PROJECT_VERSION__ +org.gradle.jvmargs=-Xmx1g diff --git a/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/settings.gradle b/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/settings.gradle new file mode 100644 index 00000000000..922d6e337a1 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/asset-classpath-packaging/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'asset-classpath-packaging' From 3fec0cd0a8e1632f41d6412718f23d2b8ccf2e3a Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 01:35:23 -0700 Subject: [PATCH 051/115] Correct the AOT cache figures Re-measured on a quiet machine, against the jar that now carries its assets on the classpath, and with both caches trained from the same archive so the two rows are comparable. Two claims were wrong. Naming paths does move startup, by about a tenth, rather than not at all; and it takes about a third off the first requests rather than half. The first figures were taken with the refresh-only cache trained from an earlier build, and some of them while the machine was busy. (cherry picked from commit f9706aa3989cf3b32cba335b4d1a716651366af0) --- .../guide/deployment/deploymentAotCache.adoc | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc index 2e63ec05d4b..6fd8383ef41 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc @@ -71,9 +71,9 @@ A JVM given a cache it cannot use does not fail. It reports why, ignores the cac === What the training run should do -A cache makes the next start fast at whatever the training run did. Training a run that only refreshes the context records the framework starting, and that alone is most of what the startup time is. +A cache makes the next start fast at whatever the training run did. Training a run that only refreshes the context records the framework starting, and that alone is most of what the startup time is — so most of the benefit is there before any path is named. -Asking for paths as well does not make startup faster still — the two caches reach the same figure. What it changes is the first request. Each path asked for during training profiles the code that answers it — URL mapping, the controller, GSP rendering, the data access behind it — so the first real request finds that work done rather than doing it itself. On the same application, the first hit of four cold paths cost around 0.95s against a cache trained on refresh alone, and around 0.48s against one trained over those paths. +Asking for paths adds a little to that and a good deal more to the first request. Each path asked for during training profiles the code that answers it — URL mapping, the controller, GSP rendering, the data access behind it — so the first real request finds that work done rather than doing it itself. So `paths` is worth setting for the pages that matter on a cold start: the ones a load balancer hits first, and the ones a user sees first. An application whose startup time is all that matters can leave it empty and still get most of the benefit. @@ -143,22 +143,22 @@ Measured on a Grails application with GORM for Hibernate, security and asset pip | Start | Startup | First hit of four cold paths | Ordinary -| 3.150s +| 2.594s | | Spring AOT -| 2.489s +| 2.284s | | Spring AOT with a cache trained on refresh only -| 1.079s -| 0.847s +| 1.015s +| 0.495s | Spring AOT with a cache trained over those paths -| 1.026s -| 0.445s +| 0.933s +| 0.332s |=== -The shape of that is the point. Spring's AOT processing on its own moves less than might be expected, because deciding what the beans are was never most of the cost — loading and linking the classes was, and that is what the cache removes, more than halving startup. The two caches then reach the same startup figure, and differ in what the application is fast at once it is up. +The shape of that is the point. Spring's AOT processing on its own moves less than might be expected, because deciding what the beans are was never most of the cost — loading and linking the classes was, and that is what the cache removes, cutting startup by more than half. Naming the paths takes a further tenth off startup and a third off the first requests. An AOT cache and a native image solve the same problem differently and are not combined: a native image has no cache to read because it has already done all of this at build time. The cache is what an application gets when it stays on the JVM — including applications a native image cannot yet build, which is most of those using Hibernate. From aeb9004179777c009262c82b782c7e232c8977c7 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 01:51:25 -0700 Subject: [PATCH 052/115] Address review of the AOT cache task Say that training does not work on Windows, before the run rather than after it. The cache is written as the training JVM exits normally, so the run has to be asked to stop -- and Process.destroy() asks on POSIX but kills on Windows, where it is TerminateProcess and no shutdown runs. The run was being exercised in full, killed, and the build then failed saying the cache was not written, which is true and useless. Skip a path that is not a URI rather than failing the build on one. A path written without its leading slash makes a URI with no valid authority, and URI.create throws IllegalArgumentException, which the IOException catch did not cover -- so a typo in a list whose purpose is to make the next start quicker failed the build with a stack trace, against this method's stated contract that nothing in it fails a build. Declare the task's caching intent, which this build requires of every custom task type, and say what the extract task reads and writes so a second run skips it rather than unpacking the same archive again. The spec now drives a training run that really starts, is asked for its paths and stops -- so the start detection, the exercise loop, the graceful stop, and the metadata that is written all have a test that fails if they break. It runs through a stand-in for the JVM rather than java -jar, because a real one would have to understand -XX:AOTCacheOutput and that would test which JDK the build runs on. Replaces a test that asserted a Gradle ListProperty returns what was set on it, which could not have failed. (cherry picked from commit c0ec7d18d390021053727c5cf36a992aad009f59) --- .../guide/deployment/deploymentAotCache.adoc | 4 + .../plugin/aot/TrainAotCacheTask.groovy | 28 ++++- .../plugin/core/GrailsGradlePlugin.groovy | 4 + .../plugin/aot/TrainAotCacheTaskSpec.groovy | 112 +++++++++++++++++- .../plugin/aot/TrainingRunFixture.groovy | 64 ++++++++++ 5 files changed, 206 insertions(+), 6 deletions(-) create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy diff --git a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc index 6fd8383ef41..cd21b8cef9d 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc @@ -23,6 +23,8 @@ The JDK can record a run of an application — the classes it loaded and linked, It requires JDK 25 or later. +Training is POSIX-only. The cache is written as the training JVM exits normally, so the run has to be asked to stop rather than killed — and a child process on Windows can only be killed. `trainAotCache` says so and stops rather than training a run it could not end. Reading a cache has no such restriction; only producing one does. + === Enabling the cache @@ -108,6 +110,8 @@ grails { `jvmArguments` is given to the training run *and* has to be given to every run that reads the cache. A cache records what it saw; a run configured differently from the training run is a different application as far as the cache is concerned, and its cache will be declined. +Because those arguments have to be reproduced at deployment time, they are recorded in `aot-cache.properties`, which ships beside the cache. Keep credentials out of them and pass them to the training run another way. + === Knowing whether a cache still applies diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index 7f34027c1ea..d3c060c9d8f 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -32,6 +32,7 @@ import org.gradle.api.tasks.Input import org.gradle.api.tasks.InputDirectory import org.gradle.api.tasks.OutputFile import org.gradle.api.tasks.TaskAction +import org.gradle.work.DisableCachingByDefault /** * Runs the application once so the JDK can write down what starting it needs. @@ -48,6 +49,7 @@ import org.gradle.api.tasks.TaskAction * @since 8.0 */ @CompileStatic +@DisableCachingByDefault(because = 'Runs the application and records what it did, which is not reproducible') abstract class TrainAotCacheTask extends DefaultTask { /** The extracted application: the cache is only usable against the layout it was trained on. */ @@ -83,6 +85,7 @@ abstract class TrainAotCacheTask extends DefaultTask { @TaskAction void train() { + refuseWhereTheRunCannotBeAskedToStop() File directory = applicationDirectory.get().asFile File cache = cacheFile.get().asFile cache.delete() @@ -115,6 +118,24 @@ abstract class TrainAotCacheTask extends DefaultTask { cache.name, (cache.length() / (1024 * 1024)) as long, paths.get().size()) } + /** + * Refuses to start a run that could not be ended properly, before it is started. + * + *

    The cache is written as the training JVM exits normally, so the run has to be asked to + * stop rather than killed. {@link Process#destroy()} asks on POSIX and kills on Windows, where + * it is {@code TerminateProcess} and no shutdown runs -- so on Windows the run would be + * exercised in full, killed, and leave no cache, and the build would fail at the end saying the + * cache was not written rather than saying why it could not be.

    + */ + private static void refuseWhereTheRunCannotBeAskedToStop() { + String os = System.getProperty('os.name', '') + if (os.toLowerCase(Locale.ROOT).contains('win')) { + throw new GradleException('Training an AOT cache needs the training run to be asked to ' + + 'stop, and on Windows a child process can only be killed -- which writes no ' + + 'cache. Train on Linux or macOS, or set grails.aotCache.enabled to false.') + } + } + /** * Writes down what the cache was made from. * @@ -177,6 +198,11 @@ abstract class TrainAotCacheTask extends DefaultTask { * Asks for each path. A path that answers with an error still profiled the code that produced * the error, which is code an application runs too, so nothing here fails the build: the run is * a recording, not a test. + * + *

    That covers a path that is not a URI as much as one that answers with a 500. A path + * written without its leading slash makes a URI with no valid authority, and rejecting it here + * would fail a build over a typo in a list whose whole purpose is to make the next start + * quicker.

    */ private void exercise() { for (String path : paths.get()) { @@ -193,7 +219,7 @@ abstract class TrainAotCacheTask extends DefaultTask { body?.withCloseable { it.bytes } logger.info('Trained {} -> {}', path, status) } - catch (IOException e) { + catch (IOException | RuntimeException e) { logger.info('Could not reach {} while training: {}', path, e.message) } } diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 205b712bdff..e8ef50f32e2 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -1198,6 +1198,10 @@ ${importStatements} task.description = 'Extracts the application, which is the form the cache is read against' task.onlyIf { extension.enabled.get() } task.dependsOn(bootJar) + // Named so the extraction is skipped when the archive it came from has not moved, + // rather than repeated on every run because nothing said what it produced. + task.inputs.file(project.provider { archiveOf(bootJar) }) + task.outputs.dir(application) task.doFirst { project.delete(application.get().asFile) application.get().asFile.mkdirs() diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index a84e589c3e6..e5928197f65 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -38,6 +38,66 @@ class TrainAotCacheTaskSpec extends Specification { Project project = ProjectBuilder.builder().build() + /** Where the fixture writes the paths it was asked for, so the spec can read them back. */ + private File requestedFile + + List getRequested() { + requestedFile?.isFile() ? requestedFile.readLines().findAll { it } : [] + } + + private static Properties describedBy(TrainAotCacheTask task) { + Properties properties = new Properties() + task.metadataFile.get().asFile.withInputStream { properties.load(it) } + properties + } + + private static String sha256Of(File file) { + java.security.MessageDigest.getInstance('SHA-256').digest(file.bytes).encodeHex().toString() + } + + /** + * A task whose training run really starts, serves and stops. + * + *

    Launched through a script standing in for the JVM: the run is given + * {@code -XX:AOTCacheOutput}, which a JDK before 25 refuses outright, and a test of this task + * should not also be a test of which JDK the build is running on.

    + */ + private TrainAotCacheTask servingTask(List paths) { + File application = new File(temporaryFolder, 'serving') + application.mkdirs() + new File(application, 'served.jar').text = 'stands in for the archive, and is what is digested' + requestedFile = new File(temporaryFolder, 'requested.txt') + requestedFile.text = '' + + File script = new File(temporaryFolder, 'fake-jvm.sh') + script.text = """#!/bin/sh +cache="" +port="" +for arg in "\$@"; do + case "\$arg" in + -XX:AOTCacheOutput=*) cache="\${arg#-XX:AOTCacheOutput=}" ;; + --server.port=*) port="\${arg#--server.port=}" ;; + esac +done +exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ + -cp '${System.getProperty('java.class.path')}' \\ + ${TrainingRunFixture.name} "\$cache" "\$port" '${requestedFile.absolutePath}' +""" + script.setExecutable(true) + + TrainAotCacheTask task = project.tasks.create('trainServing', TrainAotCacheTask) + task.applicationDirectory.set(application) + task.archiveFileName.set('served.jar') + task.cacheFile.set(new File(application, 'demo.aot')) + task.metadataFile.set(new File(application, 'aot-cache.properties')) + task.javaExecutable.set(script.absolutePath) + task.jvmArguments.set(['-Dspring.aot.enabled=true']) + task.paths.set(paths) + task.port.set(18098) + task.startTimeoutSeconds.set(60) + task + } + private TrainAotCacheTask task(String archiveName, List arguments) { File application = new File(temporaryFolder, 'application') application.mkdirs() @@ -79,11 +139,53 @@ class TrainAotCacheTaskSpec extends Specification { new File(e.message.replaceAll(/(?s).*is in /, '').trim()).isFile() } - void 'the arguments the run is trained with are the ones it is given'() { - given: - TrainAotCacheTask task = task('not-an-archive.jar', ['-Dspring.aot.enabled=true']) + void 'a run that starts is exercised and described'() { + given: 'a run that says it started, serves what it is asked for, and stops when asked' + TrainAotCacheTask task = servingTask(['/', '/login', '/missing']) + + when: + task.train() + + then: 'the cache the run left behind is described by what it was made from' + Properties described = describedBy(task) + described.'application.archive' == 'served.jar' + described.'application.sha256' == sha256Of(new File(task.applicationDirectory.get().asFile, 'served.jar')) + described.'training.paths' == '/ /login /missing' + described.'training.arguments' == '-Dspring.aot.enabled=true' + described.'java.runtime.version' == System.getProperty('java.runtime.version') + + and: 'every path was asked for, including the one that answered with an error' + requested == ['/', '/login', '/missing'] + } + + void 'a path that is not a URI is skipped rather than failing the build'() { + given: 'a leading slash left off, which makes a URI with no valid authority' + TrainAotCacheTask task = servingTask(['login', '/']) + + when: + task.train() + + then: 'a typo in a list that exists to make the next start quicker does not fail a build' + noExceptionThrown() + + and: 'the paths that are URIs were still asked for' + requested == ['/'] + } + + void 'a run is refused where it could not be asked to stop'() { + given: 'Windows, where a child process can only be killed, and a killed run writes no cache' + String os = System.getProperty('os.name') + System.setProperty('os.name', 'Windows 11') + TrainAotCacheTask task = task('not-an-archive.jar', []) + + when: + task.train() + + then: 'said before the run rather than after it, as "no cache was written"' + GradleException e = thrown() + e.message.contains('can only be killed') - expect: 'a run configured differently from the training run reads a cache of another application' - task.jvmArguments.get() == ['-Dspring.aot.enabled=true'] + cleanup: + System.setProperty('os.name', os) } } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy new file mode 100644 index 00000000000..75a8893490b --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy @@ -0,0 +1,64 @@ +/* + * 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.grails.gradle.plugin.aot + +import java.util.concurrent.CountDownLatch + +import com.sun.net.httpserver.HttpExchange +import com.sun.net.httpserver.HttpServer + +/** + * Stands in for the application a training run starts, so the run can be exercised for real. + * + *

    It does the three things {@link TrainAotCacheTask} depends on and nothing else: it says it + * started the way Spring Boot says it, it answers on the paths it is asked for and writes down + * which, and it writes its cache while shutting down rather than when told to stop -- which is what + * makes a killed run leave nothing behind.

    + * + *

    Run by the script the spec writes, not by {@code java -jar}: a real JVM would have to + * understand {@code -XX:AOTCacheOutput}, which ties the test to the JDK the build happens to run + * on.

    + */ +class TrainingRunFixture { + + static void main(String[] args) { + File cache = new File(args[0]) + int port = Integer.parseInt(args[1]) + File requested = new File(args[2]) + + HttpServer server = HttpServer.create(new InetSocketAddress('localhost', port), 0) + server.createContext('/') { HttpExchange exchange -> + requested << "${exchange.requestURI.path}\n" + byte[] body = 'served'.bytes + int status = exchange.requestURI.path == '/missing' ? 404 : 200 + exchange.sendResponseHeaders(status, body.length) + exchange.responseBody.withCloseable { it.write(body) } + } + server.start() + + Runtime.runtime.addShutdownHook(new Thread({ + cache.text = 'a cache is what a run leaves behind as it goes' + })) + + println 'Started Application in 0.05 seconds' + System.out.flush() + + new CountDownLatch(1).await() + } +} From b2009c43828f6d97805a3a40fb216943546b0d87 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 08:47:40 -0700 Subject: [PATCH 053/115] Assert what the registrar now says these beans produce The definitions declare InstanceFactoryBean rather than T, so that the bean a definition stands for is known from the definition alone -- which is what generating bean definitions as code requires, and what asking the factory would have prevented, since asking it means creating it. The spec still asserted the older shape and had been failing since the change. (cherry picked from commit a6cf3dd2329346e9a0e4c698ae7c22fa7cca6780) --- ...storeConnectionSourcesRegistrarSpec.groovy | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrarSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrarSpec.groovy index 7e103bd075e..416fc881a45 100644 --- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrarSpec.groovy +++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/support/HibernateDatastoreConnectionSourcesRegistrarSpec.groovy @@ -30,6 +30,18 @@ import javax.sql.DataSource class HibernateDatastoreConnectionSourcesRegistrarSpec extends HibernateGormDatastoreSpec { + /** + * What a definition says it will produce, without producing it. + * + *

    These are factory beans, so the bean a definition stands for is the factory's type + * argument rather than the factory. Naming it on the definition is what lets the type be known + * from the definition alone -- which is what generating bean definitions as code requires, and + * what asking the factory would have prevented, since asking it means creating it.

    + */ + private static Class produces(def definition) { + definition.targetType == InstanceFactoryBean ? definition.resolvableType.getGeneric(0).resolve() : null + } + def "test postProcessBeanDefinitionRegistry registers expected beans"() { given: def registry = new DefaultListableBeanFactory() @@ -44,28 +56,28 @@ class HibernateDatastoreConnectionSourcesRegistrarSpec extends HibernateGormData registry.containsBeanDefinition(Settings.SETTING_DATASOURCE) def defaultDs = registry.getBeanDefinition(Settings.SETTING_DATASOURCE) defaultDs.beanClass == InstanceFactoryBean - defaultDs.targetType == DataSource + produces(defaultDs) == DataSource defaultDs.constructorArgumentValues.genericArgumentValues[0].value == "#{dataSourceConnectionSourceFactory.create('dataSource', environment).source}" // Secondary dataSource bean registry.containsBeanDefinition("${Settings.SETTING_DATASOURCE}_readOnly") def readOnlyDs = registry.getBeanDefinition("${Settings.SETTING_DATASOURCE}_readOnly") readOnlyDs.beanClass == InstanceFactoryBean - readOnlyDs.targetType == DataSource + produces(readOnlyDs) == DataSource readOnlyDs.constructorArgumentValues.genericArgumentValues[0].value == "#{dataSourceConnectionSourceFactory.create('readOnly', environment).source}" // Secondary sessionFactory bean registry.containsBeanDefinition("sessionFactory_readOnly") def readOnlySf = registry.getBeanDefinition("sessionFactory_readOnly") readOnlySf.beanClass == InstanceFactoryBean - readOnlySf.targetType == SessionFactory + produces(readOnlySf) == SessionFactory readOnlySf.constructorArgumentValues.genericArgumentValues[0].value == "#{hibernateDatastore.getDatastoreForConnection('readOnly').sessionFactory}" // Secondary transactionManager bean registry.containsBeanDefinition("transactionManager_readOnly") def readOnlyTm = registry.getBeanDefinition("transactionManager_readOnly") readOnlyTm.beanClass == InstanceFactoryBean - readOnlyTm.targetType == PlatformTransactionManager + produces(readOnlyTm) == PlatformTransactionManager readOnlyTm.constructorArgumentValues.genericArgumentValues[0].value == "#{hibernateDatastore.getDatastoreForConnection('readOnly').transactionManager}" // Default sessionFactory and transactionManager should NOT be registered by this registrar From ac9075ac5d5cc14307b0722ab08baab8ce3798bb Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 08:47:41 -0700 Subject: [PATCH 054/115] Follow every type a class file names, not some of them This decides whether a scanned type can be registered for reflection, and gets it wrong in one direction only: a type it wrongly accepts fails the image build, which is what it exists to prevent. It read supertypes, method parameters, and the owners of the calls and field accesses in a method body. So a class naming an absent type as a field's type, a return type, something it throws or catches, an argument of a call, or a class literal was accepted -- and an array of an absent type was discarded outright, since the name of an array was skipped rather than reduced to the element type that has to exist. Now also read fields, return types, exceptions, the descriptors of calls and field accesses, constants, and invokedynamic -- which for Groovy is not an edge case but how a call site names what it dispatches on. The spec writes a class naming an absent type in one place and nowhere else, once per place, and the same class naming a type that loads: so a rejection is the absent type rather than the shape it was named in. (cherry picked from commit 0a67cd8e679bb9da32a2d44694d3b967bd645c45) --- .../org/grails/aot/RegistrableTypes.java | 102 +++++++++++++++- .../grails/aot/RegistrableTypesSpec.groovy | 110 ++++++++++++++++++ 2 files changed, 209 insertions(+), 3 deletions(-) diff --git a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java b/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java index 37055a3bc99..1516677c5e6 100644 --- a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java +++ b/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java @@ -25,6 +25,10 @@ import org.springframework.asm.ClassReader; import org.springframework.asm.ClassVisitor; +import org.springframework.asm.ConstantDynamic; +import org.springframework.asm.FieldVisitor; +import org.springframework.asm.Handle; +import org.springframework.asm.Label; import org.springframework.asm.MethodVisitor; import org.springframework.asm.SpringAsmInfo; import org.springframework.asm.Type; @@ -104,7 +108,12 @@ private ReferenceCollector(Set referenced) { } private void add(@Nullable String internalName) { - if (internalName == null || internalName.startsWith("[")) { + if (internalName == null) { + return; + } + if (internalName.startsWith("[")) { + // an array names its element type, which is the class that has to be there + addType(Type.getType(internalName)); return; } String className = ClassUtils.convertResourcePathToClassName(internalName); @@ -114,6 +123,54 @@ private void add(@Nullable String internalName) { } } + /** Adds a type, reducing an array to the element type it is an array of. */ + private void addType(@Nullable Type type) { + if (type == null) { + return; + } + Type element = type; + while (element.getSort() == Type.ARRAY) { + element = element.getElementType(); + } + if (element.getSort() == Type.OBJECT) { + add(element.getInternalName()); + } + } + + /** Adds every type a method descriptor names: what it takes and what it gives back. */ + private void addMethodDescriptor(@Nullable String descriptor) { + if (descriptor == null) { + return; + } + for (Type argument : Type.getArgumentTypes(descriptor)) { + addType(argument); + } + addType(Type.getReturnType(descriptor)); + } + + /** Adds whichever constant carries a type: a class literal, a handle, or a method type. */ + private void addConstant(@Nullable Object constant) { + if (constant instanceof Type type) { + if (type.getSort() == Type.METHOD) { + addMethodDescriptor(type.getDescriptor()); + } + else { + addType(type); + } + } + else if (constant instanceof Handle handle) { + add(handle.getOwner()); + addMethodDescriptor(handle.getDesc()); + } + else if (constant instanceof ConstantDynamic dynamic) { + addType(Type.getType(dynamic.getDescriptor())); + add(dynamic.getBootstrapMethod().getOwner()); + for (int i = 0; i < dynamic.getBootstrapMethodArgumentCount(); i++) { + addConstant(dynamic.getBootstrapMethodArgument(i)); + } + } + } + @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { @@ -125,11 +182,21 @@ public void visit(int version, int access, String name, String signature, String } } + @Override + public FieldVisitor visitField(int access, String name, String descriptor, String signature, + Object value) { + addType(Type.getType(descriptor)); + return null; + } + @Override public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) { - for (Type argument : Type.getArgumentTypes(descriptor)) { - add(argument.getSort() == Type.OBJECT ? argument.getInternalName() : null); + addMethodDescriptor(descriptor); + if (exceptions != null) { + for (String each : exceptions) { + add(each); + } } return new MethodVisitor(SpringAsmInfo.ASM_VERSION) { @Override @@ -141,12 +208,41 @@ public void visitTypeInsn(int opcode, String type) { public void visitMethodInsn(int opcode, String owner, String methodName, String methodDescriptor, boolean isInterface) { add(owner); + addMethodDescriptor(methodDescriptor); } @Override public void visitFieldInsn(int opcode, String owner, String fieldName, String fieldDescriptor) { add(owner); + addType(Type.getType(fieldDescriptor)); + } + + @Override + public void visitLdcInsn(Object value) { + // a class literal, which names a type without ever calling anything on it + addConstant(value); + } + + @Override + public void visitInvokeDynamicInsn(String methodName, String methodDescriptor, + Handle bootstrap, Object... arguments) { + // how a Groovy call site names what it dispatches on + addMethodDescriptor(methodDescriptor); + addConstant(bootstrap); + for (Object argument : arguments) { + addConstant(argument); + } + } + + @Override + public void visitMultiANewArrayInsn(String descriptor, int dimensions) { + addType(Type.getType(descriptor)); + } + + @Override + public void visitTryCatchBlock(Label start, Label end, Label handler, String type) { + add(type); } }; } diff --git a/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy b/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy index 35953fcab68..3319fa77ddc 100644 --- a/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy +++ b/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy @@ -18,6 +18,13 @@ */ package org.grails.aot +import org.springframework.asm.ClassWriter +import org.springframework.asm.Handle +import org.springframework.asm.Label +import org.springframework.asm.MethodVisitor +import org.springframework.asm.Opcodes +import org.springframework.asm.Type + import spock.lang.Specification /** @@ -72,6 +79,109 @@ class RegistrableTypesSpec extends Specification { RegistrableTypes.loads('java.lang.String', empty) } + void 'bytecode is rejected wherever the absent type is named'() { + expect: 'each of these names it once and nowhere else, so each stands or falls on its own' + !RegistrableTypes.referencesLoad(namingAbsent(shape), loader) + + where: + shape << Shape.values() + } + + void 'the same shapes naming a type that loads are accepted'() { + expect: 'so the rejections above are the absent type and not the shape it was named in' + RegistrableTypes.referencesLoad(naming('java/lang/Number', shape), loader) + + where: + shape << Shape.values() + } + + /** The places a class file can name a type, one per shape. */ + private enum Shape { + FIELD_TYPE, ARRAY_FIELD_TYPE, RETURN_TYPE, PARAMETER_TYPE, THROWN_TYPE, + CLASS_LITERAL, CAUGHT_TYPE, CALL_ARGUMENT_TYPE, INVOKEDYNAMIC_ARGUMENT + } + + private InputStream namingAbsent(Shape shape) { + naming('com/example/Absent', shape) + } + + /** + * A class naming the given type in one place only. + * + *

    Written rather than compiled because the point is the single mention: a fixture compiled + * from source names its own package, its supertypes and whatever the compiler adds, and would + * pass or fail for reasons other than the one under test.

    + */ + private InputStream naming(String internalName, Shape shape) { + ClassWriter writer = new ClassWriter(0) + writer.visit(Opcodes.V21, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, + 'org/grails/aot/Written', null, 'java/lang/Object', null) + String descriptor = "L${internalName};" + + switch (shape) { + case Shape.FIELD_TYPE -> + writer.visitField(Opcodes.ACC_PRIVATE, 'held', descriptor, null, null).visitEnd() + case Shape.ARRAY_FIELD_TYPE -> + writer.visitField(Opcodes.ACC_PRIVATE, 'held', "[[${descriptor}", null, null).visitEnd() + case Shape.RETURN_TYPE -> + writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, + 'give', "()${descriptor}", null, null).visitEnd() + case Shape.PARAMETER_TYPE -> + writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, + 'take', "(${descriptor})V", null, null).visitEnd() + case Shape.THROWN_TYPE -> + writer.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, + 'fail', '()V', null, [internalName] as String[]).visitEnd() + default -> withBody(writer, internalName, descriptor, shape) + } + + writer.visitEnd() + new ByteArrayInputStream(writer.toByteArray()) + } + + private void withBody(ClassWriter writer, String internalName, String descriptor, Shape shape) { + MethodVisitor method = writer.visitMethod(Opcodes.ACC_PUBLIC, 'body', '()V', null, null) + method.visitCode() + switch (shape) { + case Shape.CLASS_LITERAL -> { + method.visitLdcInsn(Type.getObjectType(internalName)) + method.visitInsn(Opcodes.POP) + } + case Shape.CAUGHT_TYPE -> { + Label start = new Label(), end = new Label(), handler = new Label() + method.visitTryCatchBlock(start, end, handler, internalName) + method.visitLabel(start) + method.visitLabel(end) + method.visitLabel(handler) + method.visitInsn(Opcodes.POP) + } + case Shape.CALL_ARGUMENT_TYPE -> { + // the owner is present; only what the call takes is not + method.visitInsn(Opcodes.ACONST_NULL) + method.visitInsn(Opcodes.ACONST_NULL) + method.visitMethodInsn(Opcodes.INVOKEVIRTUAL, 'java/lang/Object', + 'equals', "(${descriptor})Z", false) + method.visitInsn(Opcodes.POP) + } + case Shape.INVOKEDYNAMIC_ARGUMENT -> { + Handle bootstrap = new Handle(Opcodes.H_INVOKESTATIC, + 'java/lang/invoke/LambdaMetafactory', 'metafactory', + '(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;' + + 'Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;' + + 'Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)' + + 'Ljava/lang/invoke/CallSite;', + false) + method.visitInvokeDynamicInsn('run', '()Ljava/lang/Runnable;', bootstrap, + Type.getType('()V'), bootstrap, Type.getType("(${descriptor})V")) + method.visitInsn(Opcodes.POP) + } + default -> throw new IllegalArgumentException("${shape} has no body") + } + method.visitInsn(Opcodes.RETURN) + method.visitMaxs(3, 1) + method.visitEnd() + } + static class Outer { String describe() { From 790b5c1f3363ee96260deedb78f8971d081333ae Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 08:47:59 -0700 Subject: [PATCH 055/115] Train on the toolchain's JDK, and leave the cache beside the application Three things, all about which JDK and which directory. Training ran on whichever JDK was running Gradle. A project on the Java 21 baseline with a Java 25 toolchain compiles with 25 and would have trained with 21, where the cache options do not exist -- and what it reported was that the training run ended before it started serving. It now runs on the toolchain where one is declared, and on the JDK running the build where one is not, which is then also the JDK that compiled the application. The metadata recorded that same JDK, so it described the build's JVM rather than the one that wrote the cache. That file exists to tell a deployment whether the cache it has still applies, and a cache is read only by the JDK build that wrote it -- so naming the wrong one is worse than naming none. It is now read from the launcher that will run the training. The cache and its metadata were written into the extracted application, which is the directory the training task declares as its input. Writing them changed that input, so the task could never be up to date and every build ran the application again to record what the last run had already recorded. They now go beside the extracted application rather than inside it. Readiness no longer rests only on Spring Boot's startup message, which is an INFO log an application may reword or switch off; a port that accepts a connection now counts too. (cherry picked from commit b32df5c6c343f250a44924e2035a87de245de4ae) --- .../guide/deployment/deploymentAotCache.adoc | 25 +++++++-- .../plugin/aot/TrainAotCacheTask.groovy | 35 +++++++++++-- .../plugin/core/GrailsGradlePlugin.groovy | 52 ++++++++++++++----- .../plugin/aot/TrainAotCacheTaskSpec.groovy | 23 ++++++-- .../plugin/aot/TrainingRunFixture.groovy | 6 ++- 5 files changed, 114 insertions(+), 27 deletions(-) diff --git a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc index cd21b8cef9d..29180c51427 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc @@ -41,7 +41,7 @@ grails { } ---- -That adds two tasks. `extractAotCacheApplication` unpacks the executable jar into `build/aot-cache/application`, and `trainAotCache` runs what it unpacked, asks for each path, and stops it: +That adds two tasks. `extractAotCacheApplication` unpacks the executable jar into `build/aot-cache/application`, and `trainAotCache` runs what it unpacked, asks for each path, stops it, and leaves the cache beside the extracted application: [source,bash] ---- @@ -59,14 +59,27 @@ The application is unpacked first because a cache is read against the layout it === Running with the cache -The extracted directory is what is deployed, and the cache is read from beside it: +`build/aot-cache` is what is deployed: the extracted application, and beside it the cache and what it was trained from. + +[source] +---- +build/aot-cache/ +├── application/ <1> +├── myapp.aot <2> +└── aot-cache.properties <3> +---- +<1> the extracted application, which is the layout the cache was trained against +<2> the cache +<3> what the cache was trained from [source,bash] ---- cd build/aot-cache/application -java -XX:AOTCache=myapp.aot -Dspring.aot.enabled=true -Dgrails.env=production -jar myapp.jar +java -XX:AOTCache=../myapp.aot -Dspring.aot.enabled=true -Dgrails.env=production -jar myapp.jar ---- +Run it from the extracted directory, as the training run was run: a cache records the classpath it saw, and reaching the same jar by a different path is a different classpath. + A JVM given a cache it cannot use does not fail. It reports why, ignores the cache, and starts as it would have anyway — so an invalid cache costs the startup time it was meant to save, silently, and without any other symptom. @@ -118,6 +131,8 @@ Because those arguments have to be reproduced at deployment time, they are recor A cache is read only by the JDK build that wrote it, against the archive it was trained on, with the arguments it was trained with. Any of those changing invalidates it, and the only symptom is that startup is no longer fast. +Training runs on the project's Java toolchain where it declares one, so the JDK recorded here is the one the application is compiled for rather than whichever one happened to run Gradle. + So the training run writes `aot-cache.properties` beside the cache, recording what it was made from: [source] @@ -128,8 +143,8 @@ application.archive=myapp-0.1.jar application.sha256=6f1b... training.arguments=-Dspring.aot.enabled=true -Dgrails.env=production training.paths=/ /login /book/index /book/show/1 -java.runtime.version=26+30-2422 -java.vm.version=26+30-2422 +java.runtime.version=26.0.2+13 +java.vendor=BellSoft os.name=Mac OS X os.arch=aarch64 ---- diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index d3c060c9d8f..3911c063ddd 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -65,6 +65,13 @@ abstract class TrainAotCacheTask extends DefaultTask { @Input abstract Property getJavaExecutable() + /** The version of the JDK above, which is the JDK the cache will only ever be readable by. */ + @Input + abstract Property getJavaVersion() + + @Input + abstract Property getJavaVendor() + /** Given to the training run, and to be given to every run that reads the cache. */ @Input abstract ListProperty getJvmArguments() @@ -152,9 +159,8 @@ abstract class TrainAotCacheTask extends DefaultTask { properties.setProperty('application.sha256', sha256(archive)) properties.setProperty('training.arguments', jvmArguments.get().join(' ')) properties.setProperty('training.paths', paths.get().join(' ')) - properties.setProperty('java.vendor', System.getProperty('java.vendor', '')) - properties.setProperty('java.runtime.version', System.getProperty('java.runtime.version', '')) - properties.setProperty('java.vm.version', System.getProperty('java.vm.version', '')) + properties.setProperty('java.vendor', javaVendor.get()) + properties.setProperty('java.runtime.version', javaVersion.get()) properties.setProperty('os.name', System.getProperty('os.name', '')) properties.setProperty('os.arch', System.getProperty('os.arch', '')) metadataFile.get().asFile.withOutputStream { OutputStream out -> @@ -175,8 +181,13 @@ abstract class TrainAotCacheTask extends DefaultTask { } /** - * Waits for the application to say it has started, and stops waiting if the run ends first -- + * Waits for the application to start serving, and stops waiting if the run ends first -- * otherwise a run that fails immediately is waited on for the whole timeout. + * + *

    Either the run says it started or its port answers. The message is Spring Boot's and is + * the earlier and clearer of the two, but it is an INFO log an application is free to turn off + * or reword; a port that accepts a connection is the application's own doing and cannot be + * configured away while it is still an application worth training.

    */ private void awaitStarted(Process process, File output) { long deadline = System.currentTimeMillis() + Duration.ofSeconds(startTimeoutSeconds.get()).toMillis() @@ -188,12 +199,28 @@ abstract class TrainAotCacheTask extends DefaultTask { if (output.isFile() && output.text.contains('Started ')) { return } + if (serving()) { + return + } Thread.sleep(250L) } throw new GradleException("The training run did not start within ${startTimeoutSeconds.get()}s. " + "What it printed is in ${output}") } + /** Whether anything is accepting connections on the port the run was told to listen on. */ + private boolean serving() { + try { + new Socket().withCloseable { Socket socket -> + socket.connect(new InetSocketAddress('localhost', port.get()), 500) + true + } + } + catch (IOException ignored) { + false + } + } + /** * Asks for each path. A path that answers with an error still profiled the code that produced * the error, which is code an application runs too, so nothing here fails the build: the run is diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index e8ef50f32e2..fd2f131738b 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -60,6 +60,7 @@ import org.gradle.api.tasks.TaskContainer import org.gradle.api.tasks.TaskProvider import org.gradle.api.tasks.compile.GroovyCompile import org.gradle.api.tasks.testing.Test +import org.gradle.jvm.toolchain.JavaLauncher import org.gradle.jvm.toolchain.JavaToolchainService import org.gradle.language.jvm.tasks.ProcessResources import org.gradle.process.JavaForkOptions @@ -1192,6 +1193,7 @@ ${importStatements} project.pluginManager.withPlugin(SPRING_BOOT_PLUGIN) { TaskProvider bootJar = project.tasks.named('bootJar') Provider application = project.layout.buildDirectory.dir('aot-cache/application') + Provider launcher = trainingLauncher(project) TaskProvider extract = project.tasks.register('extractAotCacheApplication', Exec) { Exec task -> task.group = BasePlugin.BUILD_GROUP @@ -1203,12 +1205,15 @@ ${importStatements} task.inputs.file(project.provider { archiveOf(bootJar) }) task.outputs.dir(application) task.doFirst { - project.delete(application.get().asFile) - application.get().asFile.mkdirs() + File destination = application.get().asFile + project.delete(destination) + destination.mkdirs() + // Set here rather than while the build is configured, so the JDK the toolchain + // resolves to is not provisioned by every build that merely reads this project. + task.commandLine(launcher.get().executablePath.asFile.absolutePath, + '-Djarmode=tools', '-jar', archiveOf(bootJar).absolutePath, 'extract', + '--destination', destination.absolutePath) } - task.commandLine(javaExecutable(project), '-Djarmode=tools', '-jar', - archiveOf(bootJar).absolutePath, 'extract', - '--destination', application.get().asFile.absolutePath) } project.tasks.register('trainAotCache', TrainAotCacheTask) { TrainAotCacheTask task -> @@ -1218,11 +1223,19 @@ ${importStatements} task.dependsOn(extract) task.applicationDirectory.set(application) task.archiveFileName.set(project.provider { archiveOf(bootJar).name }) - task.cacheFile.set(application.map { Directory dir -> - dir.file("${project.name}.aot") - }) - task.metadataFile.set(application.map { Directory dir -> dir.file('aot-cache.properties') }) - task.javaExecutable.set(javaExecutable(project)) + // Beside the extracted application rather than inside it. Inside, the cache and its + // metadata land in the directory this task declares as its input, so writing them + // changes that input and the task can never be up to date -- every build would run + // the application again to record what the last one already recorded. + Provider beside = project.layout.buildDirectory.dir('aot-cache') + task.cacheFile.set(beside.map { Directory dir -> dir.file("${project.name}.aot") }) + task.metadataFile.set(beside.map { Directory dir -> dir.file('aot-cache.properties') }) + task.javaExecutable.set(launcher.map { JavaLauncher java -> java.executablePath.asFile.absolutePath }) + // Recorded from the JDK that will run the training, not the one running the build. + // A cache is read only by the JDK build that wrote it, and this is what a deployment + // checks that against -- so naming the wrong one is worse than naming none. + task.javaVersion.set(launcher.map { JavaLauncher java -> java.metadata.jvmVersion }) + task.javaVendor.set(launcher.map { JavaLauncher java -> java.metadata.vendor }) task.jvmArguments.set(extension.jvmArguments) task.paths.set(extension.paths) task.port.set(extension.port) @@ -1237,9 +1250,22 @@ ${importStatements} archive.get().asFile } - /** The JDK running the build, which is the JDK the cache is tied to. */ - private static String javaExecutable(Project project) { - new File(System.getProperty('java.home'), 'bin/java').absolutePath + /** + * The JDK the cache will be trained on, which is the project's toolchain where it declares one. + * + *

    A cache is read only by the JDK build that wrote it, so training has to happen on the JDK + * the application is compiled for rather than whichever one happens to be running Gradle. A + * project on the Java 21 baseline with a Java 25 toolchain compiles with 25 and would otherwise + * have trained with 21, where the cache options do not exist -- and the failure it reported was + * that the training run ended before it started serving.

    + * + *

    Where no toolchain is declared this resolves to the JDK running the build, which is also + * the one that compiled the application.

    + */ + private static Provider trainingLauncher(Project project) { + JavaToolchainService toolchains = project.extensions.getByType(JavaToolchainService) + JavaPluginExtension java = project.extensions.getByType(JavaPluginExtension) + toolchains.launcherFor(java.toolchain) } /** diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index e5928197f65..e812bd72a9f 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -62,7 +62,7 @@ class TrainAotCacheTaskSpec extends Specification { * {@code -XX:AOTCacheOutput}, which a JDK before 25 refuses outright, and a test of this task * should not also be a test of which JDK the build is running on.

    */ - private TrainAotCacheTask servingTask(List paths) { + private TrainAotCacheTask servingTask(List paths, boolean announcesItself = true) { File application = new File(temporaryFolder, 'serving') application.mkdirs() new File(application, 'served.jar').text = 'stands in for the archive, and is what is digested' @@ -81,7 +81,7 @@ for arg in "\$@"; do done exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ -cp '${System.getProperty('java.class.path')}' \\ - ${TrainingRunFixture.name} "\$cache" "\$port" '${requestedFile.absolutePath}' + ${TrainingRunFixture.name} "\$cache" "\$port" '${requestedFile.absolutePath}' ${announcesItself ? 'loud' : 'quiet'} """ script.setExecutable(true) @@ -91,6 +91,8 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ task.cacheFile.set(new File(application, 'demo.aot')) task.metadataFile.set(new File(application, 'aot-cache.properties')) task.javaExecutable.set(script.absolutePath) + task.javaVersion.set('25.0.1+9') + task.javaVendor.set('A Vendor') task.jvmArguments.set(['-Dspring.aot.enabled=true']) task.paths.set(paths) task.port.set(18098) @@ -108,6 +110,8 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ task.cacheFile.set(new File(application, 'demo.aot')) task.metadataFile.set(new File(application, 'aot-cache.properties')) task.javaExecutable.set(new File(System.getProperty('java.home'), 'bin/java').absolutePath) + task.javaVersion.set('25.0.1+9') + task.javaVendor.set('A Vendor') task.jvmArguments.set(arguments) task.paths.set([]) task.port.set(18099) @@ -152,7 +156,8 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ described.'application.sha256' == sha256Of(new File(task.applicationDirectory.get().asFile, 'served.jar')) described.'training.paths' == '/ /login /missing' described.'training.arguments' == '-Dspring.aot.enabled=true' - described.'java.runtime.version' == System.getProperty('java.runtime.version') + described.'java.runtime.version' == '25.0.1+9' + described.'java.vendor' == 'A Vendor' and: 'every path was asked for, including the one that answered with an error' requested == ['/', '/login', '/missing'] @@ -172,6 +177,18 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ requested == ['/'] } + void 'a run that says nothing is found by its port'() { + given: 'an application that has turned off the log line Spring Boot starts with' + TrainAotCacheTask task = servingTask(['/'], false) + + when: + task.train() + + then: 'a message an application may reword or silence is not the only way to know it is up' + noExceptionThrown() + requested == ['/'] + } + void 'a run is refused where it could not be asked to stop'() { given: 'Windows, where a child process can only be killed, and a killed run writes no cache' String os = System.getProperty('os.name') diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy index 75a8893490b..89e7af2a8bb 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy @@ -56,8 +56,10 @@ class TrainingRunFixture { cache.text = 'a cache is what a run leaves behind as it goes' })) - println 'Started Application in 0.05 seconds' - System.out.flush() + if (args.length < 4 || args[3] != 'quiet') { + println 'Started Application in 0.05 seconds' + System.out.flush() + } new CountDownLatch(1).await() } From 03b9909ba4ed9e588dcd5f93edfb216378c5fe74 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 12:52:13 -0700 Subject: [PATCH 056/115] Say under the banner how the application was started An image, a JVM handed a cache to read, and one running bean definitions that were generated all start differently from an ordinary one, and until now all looked the same. The banner now says which, centred under the art and above the versions, strongest first: NATIVE, AOT CACHE, AOT. An ordinary start says nothing, so the line appears only where there is something to say. In its own colour, brighter than the art, so that what an application was started as does not read as the last line of the drawing above it. Written plainly rather than drawn over time. A banner is printed on the thread that is starting the application, which cannot get on until this returns, so anything animated here is time the application is not starting -- and an image that starts in two thirds of a second should not spend a third of it announcing itself. The cache is detected from the arguments the JVM was started with rather than from the cache itself: a JVM handed one it cannot use declines it and starts as it would have anyway, so the mark says what was asked for, not what was obtained. --- .../groovy/grails/boot/GrailsBanner.groovy | 113 +++++++++++- ...itional-spring-configuration-metadata.json | 17 ++ .../boot/GrailsBannerNativeMarkSpec.groovy | 172 ++++++++++++++++++ .../conf/applicationClass/customizing.adoc | 10 + 4 files changed, 307 insertions(+), 5 deletions(-) create mode 100644 grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 73e5c268a03..8804c8eade2 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -18,6 +18,8 @@ */ package grails.boot +import java.lang.management.ManagementFactory + import groovy.transform.CompileStatic import groovy.transform.MapConstructor import groovy.transform.stc.ClosureParams @@ -29,6 +31,8 @@ import org.springframework.boot.ansi.AnsiColor import org.springframework.boot.ansi.AnsiElement import org.springframework.boot.ansi.AnsiOutput import org.springframework.boot.SpringBootVersion +import org.springframework.aot.AotDetector +import org.springframework.core.NativeDetector import org.springframework.core.SpringVersion import org.springframework.core.env.Environment import org.springframework.core.io.ClassPathResource @@ -49,6 +53,20 @@ class GrailsBanner implements Banner { private static final String ART_COLOR_PROPERTY = 'grails.banner.art.color' + private static final String MARK_DISPLAY_PROPERTY = 'grails.banner.mark.display' + + private static final String MARK_TEXT_PROPERTY = 'grails.banner.mark.text' + + private static final String MARK_COLOR_PROPERTY = 'grails.banner.mark.color' + + /** Bright yellow, so the mark reads as its own thing rather than the last line of the art. */ + private static final String DEFAULT_MARK_COLOR = '226' + + /** What an application was started as, strongest first. */ + private static final String NATIVE_MARK = 'NATIVE' + private static final String CACHE_MARK = 'AOT CACHE' + private static final String AOT_MARK = 'AOT' + /** One of the 256 colours a terminal offers: the amber the framework is shown in. */ private static final String DEFAULT_ART_COLOR = '214' @@ -80,6 +98,7 @@ class GrailsBanner implements Banner { out.println(colour(art, environment)) artPaddingBottom.times { out.println() } } + printMark(environment, out, bannerWidth) if (shouldDisplayVersions(environment)) { createVersionsFormatter().format(createBannerVersions(environment), bannerWidth) .forEach { out.println(it) } @@ -87,6 +106,75 @@ class GrailsBanner implements Banner { bannerPaddingBottom.times { out.println() } } + /** + * Marks how the application was started, centred under the art and above the versions. + * + *

    Only where it is worth saying: an image, a JVM given a cache to read, or one running bean + * definitions that were generated. An ordinary start says nothing.

    + * + *

    Written plainly, and deliberately: a banner is printed on the thread that is starting the + * application, which cannot get on until this returns. Anything drawn over time here is time the + * application is not starting, and an image that starts in two thirds of a second should not + * spend a third of it on its own announcement.

    + */ + protected void printMark(Environment environment, PrintStream out, int bannerWidth) { + if (!environment.getProperty(MARK_DISPLAY_PROPERTY, Boolean, true)) { + return + } + String mark = resolveMark(environment) + if (!mark) { + return + } + String label = spaced(mark) + String indent = ' ' * Math.max(0, (bannerWidth - label.length()).intdiv(2)) + AnsiElement colour = resolveMarkColour(environment) + out.println(indent + (colour == null ? label : AnsiOutput.toString(colour, label, AnsiColor.DEFAULT))) + } + + /** + * What to say, strongest first, or nothing where an application started the ordinary way. + * + *

    An image has already done all of it. A cache means the JDK was handed what a previous run + * worked out. Generated bean definitions are the smaller half of the same idea, and worth + * saying on their own because an application can be run either with them or without.

    + */ + protected String resolveMark(Environment environment) { + String configured = environment.getProperty(MARK_TEXT_PROPERTY, String) + if (configured != null) { + return configured.trim() ?: null + } + if (isNativeImage()) { + return NATIVE_MARK + } + if (readsAotCache()) { + return CACHE_MARK + } + AotDetector.useGeneratedArtifacts() ? AOT_MARK : null + } + + /** + * Whether the JDK was given a cache to read. + * + *

    Asked of the arguments the JVM was started with rather than of the cache: a JVM handed one + * it cannot use declines it and starts as it would have anyway, and this is the banner rather + * than a diagnostic.

    + */ + protected boolean readsAotCache() { + ManagementFactory.runtimeMXBean.inputArguments.any { String argument -> + argument.startsWith('-XX:AOTCache=') || argument.startsWith('-XX:AOTMode=') + } + } + + /** Spaced so it reads as a mark rather than a word. */ + private static String spaced(String word) { + word.toUpperCase().toCharArray().join(' ') + } + + /** Whether this is running as an image. A seam, so the mark can be covered without being one. */ + protected boolean isNativeImage() { + NativeDetector.inNativeImage() + } + /** * The art in the configured colour, or as it stands where none is wanted. * @@ -108,7 +196,22 @@ class GrailsBanner implements Banner { * the colour of a banner.

    */ protected AnsiElement resolveArtColour(Environment environment) { - String configured = environment.getProperty(ART_COLOR_PROPERTY, String, DEFAULT_ART_COLOR) + resolveColour(environment, ART_COLOR_PROPERTY, DEFAULT_ART_COLOR) + } + + /** + * The colour to show the mark in, read from {@code grails.banner.mark.color}. + * + *

    Its own colour rather than the art's, and brighter, so that what an application was started + * as is not read as the last line of the drawing above it. Takes the same values as + * {@code grails.banner.art.color}.

    + */ + protected AnsiElement resolveMarkColour(Environment environment) { + resolveColour(environment, MARK_COLOR_PROPERTY, DEFAULT_MARK_COLOR) + } + + private AnsiElement resolveColour(Environment environment, String property, String fallback) { + String configured = environment.getProperty(property, String, fallback) if (!configured || configured.equalsIgnoreCase(NO_COLOR)) { return null } @@ -116,18 +219,18 @@ class GrailsBanner implements Banner { int code = configured.toInteger() // A terminal offers 256 of them, and anything else writes an escape it does not // understand -- which shows as the escape itself, printed into the banner. - return code in 0..255 ? Ansi8BitColor.foreground(code) : defaultArtColour() + return code in 0..255 ? Ansi8BitColor.foreground(code) : defaultColour(fallback) } try { return AnsiColor.valueOf(configured.toUpperCase()) } catch (IllegalArgumentException ignored) { - return defaultArtColour() + return defaultColour(fallback) } } - private AnsiElement defaultArtColour() { - Ansi8BitColor.foreground(DEFAULT_ART_COLOR.toInteger()) + private static AnsiElement defaultColour(String fallback) { + Ansi8BitColor.foreground(fallback.toInteger()) } /** diff --git a/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json index 9ceecec922d..d6119f9aa04 100644 --- a/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/grails-core/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -18,6 +18,23 @@ "description": "The colour to show the banner art in, where the terminal colours output at all. A number selects one of the 256 colours a terminal offers; a name selects one of the eight it has always had, such as red or bright_blue; none leaves the art uncoloured. A value that is neither falls back to the default.", "defaultValue": "214" }, + { + "name": "grails.banner.mark.display", + "type": "java.lang.Boolean", + "description": "Whether to say under the banner art how the application was started: NATIVE for an image, AOT CACHE for a JVM given a cache to read, AOT for one running generated bean definitions. An ordinary start says nothing.", + "defaultValue": true + }, + { + "name": "grails.banner.mark.color", + "type": "java.lang.String", + "description": "The colour to show the mark in, separate from the art so it is not read as part of it. Takes the same values as grails.banner.art.color: a number for one of the 256 colours a terminal offers, a name for one of the eight it has always had, or none.", + "defaultValue": "226" + }, + { + "name": "grails.banner.mark.text", + "type": "java.lang.String", + "description": "Says this instead of what was detected. Shown spaced and in upper case, and an empty value shows nothing." + }, { "name": "grails.banner.versions.display", "description": "Whether to display version information in the Grails banner.", diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy new file mode 100644 index 00000000000..5c03b85fa90 --- /dev/null +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy @@ -0,0 +1,172 @@ +/* + * 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 grails.boot + +import org.springframework.boot.ansi.Ansi8BitColor +import org.springframework.boot.ansi.AnsiOutput +import org.springframework.core.env.MapPropertySource +import org.springframework.core.env.StandardEnvironment +import spock.lang.Specification + +/** + * Covers the banner saying how an application was started, under the art and above the versions. + * + *

    Written plainly. A banner is printed on the thread that is starting the application, so + * anything drawn over time here is time the application is not starting.

    + */ +class GrailsBannerNativeMarkSpec extends Specification { + + /** A banner told what it was started as, so the marks can be covered without being one. */ + static class StartedAs extends GrailsBanner { + + boolean image + boolean cache + + @Override + protected boolean isNativeImage() { + image + } + + @Override + protected boolean readsAotCache() { + cache + } + } + + StandardEnvironment environment = new StandardEnvironment() + + void cleanup() { + AnsiOutput.setEnabled(AnsiOutput.Enabled.DETECT) + System.clearProperty('spring.aot.enabled') + } + + private void configured(Map properties) { + environment.propertySources.addFirst(new MapPropertySource('test', properties)) + } + + private String printed(GrailsBanner banner) { + ByteArrayOutputStream bytes = new ByteArrayOutputStream() + banner.printBanner(environment, GrailsBannerNativeMarkSpec, new PrintStream(bytes)) + bytes.toString() + } + + private String plain(GrailsBanner banner) { + AnsiOutput.setEnabled(AnsiOutput.Enabled.NEVER) + printed(banner) + } + + void 'an ordinary start says nothing'() { + expect: 'no image, no cache, and bean definitions worked out as it went' + String output = plain(new StartedAs()) + !output.contains('N A T I V E') + !output.contains('A O T') + } + + void 'an image says so'() { + expect: + plain(new StartedAs(image: true)).contains('N A T I V E') + } + + void 'a run given a cache to read says so'() { + expect: + plain(new StartedAs(cache: true)).contains('A O T C A C H E') + } + + void 'a run on generated bean definitions says so'() { + given: 'the smaller half of the same idea, and a thing an application can be run without' + System.setProperty('spring.aot.enabled', 'true') + + expect: + plain(new StartedAs()).contains('A O T') + } + + void 'an image outranks a cache, which outranks generated definitions'() { + given: + System.setProperty('spring.aot.enabled', 'true') + + expect: 'an image has already done all of it, so it is the only thing worth saying' + plain(new StartedAs(image: true, cache: true)).contains('N A T I V E') + } + + void 'the mark sits under the art and above the versions'() { + when: + String output = plain(new StartedAs(image: true)) + + then: + output.indexOf('N A T I V E') > output.indexOf('grails.apache.org') + output.indexOf('N A T I V E') < output.indexOf('Grails:') + } + + void 'the mark is centred on the art'() { + when: + List lines = plain(new StartedAs(image: true)).readLines() + String mark = lines.find { it.contains('N A T I V E') } + int artWidth = lines*.length().max() + + then: 'the same space either side, give or take the odd character' + int leading = mark.length() - mark.stripLeading().length() + int trailing = artWidth - mark.length() + Math.abs(leading - trailing) <= 1 + } + + void 'nothing is drawn over, wherever it is read'() { + when: 'a terminal, a redirected log, or an application that has turned colour off' + String output = plain(new StartedAs(image: true)) + + then: 'one word, once, and nothing drawn over' + output.count('N A T I V E') == 1 + !output.contains('\r') + } + + void 'an application can say something else'() { + expect: + configured(['grails.banner.mark.text': 'Leyden']) + plain(new StartedAs(cache: true)).contains('L E Y D E N') + } + + void 'the mark is a different colour from the art'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + + when: 'the art amber and the mark bright yellow, so one is not read as part of the other' + String output = printed(new StartedAs(image: true)) + String markLine = output.readLines().find { it.contains('N A T I V E') } + + then: + markLine.contains(AnsiOutput.encode(Ansi8BitColor.foreground(226))) + !markLine.contains(AnsiOutput.encode(Ansi8BitColor.foreground(214))) + } + + void 'an application can choose the colour the mark is shown in'() { + given: + AnsiOutput.setEnabled(AnsiOutput.Enabled.ALWAYS) + configured(['grails.banner.mark.color': '39']) + + expect: + printed(new StartedAs(image: true)).readLines() + .find { it.contains('N A T I V E') } + .contains(AnsiOutput.encode(Ansi8BitColor.foreground(39))) + } + + void 'an application can turn the mark off altogether'() { + expect: + configured(['grails.banner.mark.display': false]) + !plain(new StartedAs(image: true)).contains('N A T I V E') + } +} diff --git a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc index 359444fb1e0..acd8ed41043 100644 --- a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc +++ b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc @@ -101,6 +101,16 @@ grails: # bright_black, bright_red, bright_green, bright_yellow, # bright_blue, bright_magenta, bright_cyan, bright_white color: 214 + mark: + # Says how the application was started, centred under the art and above the versions: + # NATIVE for a GraalVM image, AOT CACHE for a JVM given a cache to read with + # -XX:AOTCache, AOT for one running bean definitions that were generated ahead of time. + # An ordinary start says nothing at all. + display: true # (default: true) + # Its own colour, brighter than the art, so the mark is not read as the last line of the + # drawing above it. Same values as grails.banner.art.color (default: 226, bright yellow). + color: 226 + text: '' # Say this instead of what was detected; empty shows nothing. versions: display: true # Whether to display version information (default: true). include: From 2187890a6a921685eee89cdbcf57d894cc18cfac Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 12:52:13 -0700 Subject: [PATCH 057/115] Keep the banner's option enums usable in an image Turning on grails.banner.versions.include stopped a native image from starting: Could not find matching constructor for: ...OptionalVersionOption(String, Integer) A Groovy enum builds its constants through a synthetic $INIT(Object[]) whose body is this(*para) -- a spread constructor call that cannot be resolved at compile time, so it goes through the metaclass and enumerates constructors reflectively. @CompileStatic does not reach it: the call site is already static (GROOVY-10845), the generated body is not. An image keeps a constructor only when asked, and the optional enum is asked for only when an application includes a version -- so an image traced with none carries no record of it, and turning a version on turns the application off. The three enums are registered here rather than left to a trace, so what an application configures does not decide whether it starts. --- .../beans/aot/GrailsBannerRuntimeHints.java | 69 ++++++++++++++++ .../resources/META-INF/spring/aot.factories | 1 + .../aot/GrailsBannerRuntimeHintsSpec.groovy | 79 +++++++++++++++++++ 3 files changed, 149 insertions(+) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java new file mode 100644 index 00000000000..013c0520e29 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java @@ -0,0 +1,69 @@ +/* + * 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.grails.spring.beans.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.aot.hint.TypeReference; +import org.springframework.lang.Nullable; + +import grails.boot.GrailsBanner; + +/** + * Keeps the banner's option enums usable in an image, including the ones an application has not + * turned on. + * + *

    A Groovy enum builds its constants in a static initialiser that reaches its own constructor + * through the metaclass rather than calling it. An image keeps a constructor only when something + * has asked it to, so the enum initialises to + * {@code Could not find matching constructor for: ...OptionalVersionOption(String, Integer)} -- + * thrown while printing the banner, before anything the application wrote has run.

    + * + *

    Which enums are reached depends on configuration: the optional ones are touched only where + * {@code grails.banner.versions.include} names something. So an image traced with nothing included + * carries no record of them, and an application that later asks for the Tomcat version gets a + * start-up failure out of a banner setting. They are registered here rather than left to a trace + * for that reason -- all three are small, and the alternative is metadata that depends on which + * options happened to be on the day it was collected.

    + * + * @since 8.0 + */ +public class GrailsBannerRuntimeHints implements RuntimeHintsRegistrar { + + private static final Class[] OPTION_TYPES = { + GrailsBanner.VersionOption.class, + GrailsBanner.DefaultVersionOption.class, + GrailsBanner.OptionalVersionOption.class + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (Class type : OPTION_TYPES) { + hints.reflection().registerType(type, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.ACCESS_DECLARED_FIELDS); + // The name Groovy looks up before deciding an enum has no metaclass of its own. It is + // not a class anyone writes, so it is named rather than referenced. + hints.reflection().registerType( + TypeReference.of("groovy.runtime.metaclass." + type.getName() + "MetaClass")); + } + } +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index c43038d0e7c..6e31fadd544 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -4,6 +4,7 @@ org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter org.springframework.aot.hint.RuntimeHintsRegistrar=\ org.grails.spring.beans.aot.BeanRegistrarRuntimeHints,\ org.grails.spring.beans.aot.GrailsApiRuntimeHints,\ +org.grails.spring.beans.aot.GrailsBannerRuntimeHints,\ org.grails.spring.beans.aot.GrailsClosureRuntimeHints,\ org.grails.spring.beans.aot.GroovyExtensionModuleRuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..7545a368bfa --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy @@ -0,0 +1,79 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeHint +import org.springframework.aot.hint.TypeReference +import spock.lang.Specification + +import grails.boot.GrailsBanner + +/** + * Covers the banner's option enums surviving into an image. + * + *

    A Groovy enum reaches its own constructor through the metaclass to build its constants, so an + * image that kept no constructor for it fails in the static initialiser -- while printing the + * banner, before the application has run. The optional enum is the one that bites: it is touched + * only where {@code grails.banner.versions.include} names something, so a traced image carries no + * record of it and turning a version on turns the application off.

    + */ +class GrailsBannerRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new GrailsBannerRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private TypeHint hintFor(Class type) { + hints.reflection().getTypeHint(TypeReference.of(type)) + } + + void 'every option enum can be constructed'() { + expect: 'the constants are built by a static initialiser that goes through the constructor' + hintFor(type)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS) + + where: + type << [GrailsBanner.VersionOption, GrailsBanner.DefaultVersionOption, + GrailsBanner.OptionalVersionOption] + } + + void 'the optional enum is registered though nothing reaches it unless it is configured'() { + expect: 'an image traced with no versions included would otherwise have no record of it' + hintFor(GrailsBanner.OptionalVersionOption) != null + } + + void 'the enums can be read and called'() { + expect: 'values() and the key each constant carries' + hintFor(type)?.memberCategories?.contains(MemberCategory.INVOKE_DECLARED_METHODS) + hintFor(type)?.memberCategories?.contains(MemberCategory.ACCESS_DECLARED_FIELDS) + + where: + type << [GrailsBanner.VersionOption, GrailsBanner.DefaultVersionOption, + GrailsBanner.OptionalVersionOption] + } + + void 'the metaclass name Groovy looks up is registered'() { + expect: 'looked up before Groovy decides the enum has no metaclass of its own' + hints.reflection().getTypeHint(TypeReference.of( + "groovy.runtime.metaclass.${GrailsBanner.OptionalVersionOption.name}MetaClass")) != null + } +} From 8ba500ddc0b2e8526664ea43db1ec1b91ef5ff3d Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 14:12:37 -0700 Subject: [PATCH 058/115] Read an optional version without setting the library going The banner reads a library's version by loading the class that carries it. It was loading it the initialising way, so the library got to do whatever it does on the way -- and Spring Security logs a line of its own from its static initialiser. That line arrived in the middle of the banner, between the mark and the very versions it was being read for: > https://grails.apache.org < N A T I V E ... INFO ... : You are running with Spring Security Core 7.1.0 nativedemo2: 0.1 | JVM: GraalVM Community 25.0.4 A version is read about a library rather than from it. The manifest is attached to the package when the class is loaded, and loading is all this needs, so the class is now loaded without being initialised. The version still reads; the library is left to start when something actually wants it. Note for anyone tempted by the other direction: reading the version through the library's own accessor -- SpringSecurityCoreVersion.getVersion() -- does not avoid this. Calling a static method initialises the class, so it logs too. --- .../groovy/grails/boot/GrailsBanner.groovy | 14 +++- .../boot/GrailsBannerVersionLookupSpec.groovy | 77 +++++++++++++++++++ 2 files changed, 89 insertions(+), 2 deletions(-) create mode 100644 grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 8804c8eade2..2e2ca812eb8 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -332,9 +332,19 @@ class GrailsBanner implements Banner { * @param className the fully qualified class name * @return the implementation version, or 'unknown' if not found */ - private static String findVersion(String className) { + /** + * The version a library records in the manifest of the jar it ships in. + * + *

    Loaded without being initialised. A version is read about a library rather than + * from it, and running a static initialiser to find one lets the library do whatever it + * does on the way -- Spring Security logs a line of its own from there, which arrived in the + * middle of the banner, between the mark and the very versions it was being read for. The + * manifest is attached to the package when the class is loaded, and loading is all this + * needs.

    + */ + protected static String findVersion(String className) { try { - def pkg = Class.forName(className).package + Package pkg = Class.forName(className, false, GrailsBanner.classLoader).package return pkg?.implementationVersion ?: 'unknown' } catch (ClassNotFoundException ignore) { return 'unknown' diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy new file mode 100644 index 00000000000..63278d08fd0 --- /dev/null +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy @@ -0,0 +1,77 @@ +/* + * 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 grails.boot + +import spock.lang.Specification + +/** + * Covers reading an optional library's version without setting the library going. + * + *

    A version is read about a library, not from it. Initialising the class to + * find one lets it do whatever it does on the way: Spring Security logs + * {@code You are running with Spring Security Core ...} from its static initialiser, and that line + * arrived in the middle of the banner -- between the mark and the very versions it was being read + * for -- because the lookup had initialised it.

    + */ +class GrailsBannerVersionLookupSpec extends Specification { + + /** + * Where the record is kept, so that reading it is not itself what sets {@link Noisy} going. + * Asking the class under test whether it was initialised initialises it. + */ + static class Record { + + static boolean noisyRan = false + } + + /** Stands in for a library that does something when it starts. */ + static class Noisy { + + static { + Record.noisyRan = true + } + } + + void 'reading a version does not set the library going'() { + when: + GrailsBanner.findVersion(Noisy.name) + + then: 'loaded, but its static initialiser has not run' + !Record.noisyRan + + and: 'and it really would have run, had the class been initialised' + Class.forName(Noisy.name, true, getClass().classLoader) + Record.noisyRan + } + + void 'a library that is not there is unknown rather than an error'() { + expect: + GrailsBanner.findVersion('com.example.NotOnTheClasspath') == 'unknown' + } + + void 'a library with no version in its manifest is unknown'() { + expect: 'test classes carry no Implementation-Version, and that is not a failure' + GrailsBanner.findVersion(Noisy.name) == 'unknown' + } + + void 'a version recorded in a manifest is read'() { + expect: 'Spock ships one, so this proves the lookup reads rather than always saying unknown' + GrailsBanner.findVersion(Specification.name) ==~ /\d+\..*/ + } +} From 8a28c10784b7477368304924230f5d2c31722a1e Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 14:43:58 -0700 Subject: [PATCH 059/115] Show Spring Security by default, and leave out what cannot be determined Spring Security was something an application had to ask for, because a version that could not be found was shown as unknown and nobody wants a banner that says it does not know. Now a version that cannot be determined is left out altogether, which is what lets it be on by default: an application with Spring Security shows it without configuring anything, and one without it says nothing rather than saying unknown. Turn it off with grails.banner.versions.exclude: [spring-security] Tomcat is read from the resource it ships its version in rather than from the manifest. The manifest route only works while a jar is a plain entry on the classpath: repackaged into an executable jar its attributes are no longer attached to the package, and an image has no jars at all -- so the container version read as unknown in exactly the two places it is most worth having. It now reads 11.0.22.0 in a native image, where it used to read nothing. findVersion returns null rather than the string unknown, so there is one way to say "no version" and the caller decides what to do about it. --- .../groovy/grails/boot/GrailsBanner.groovy | 49 ++++++++++++++----- .../boot/GrailsBannerNativeMarkSpec.groovy | 22 ++++++++- .../boot/GrailsBannerVersionLookupSpec.groovy | 10 ++-- .../conf/applicationClass/customizing.adoc | 10 ++-- 4 files changed, 68 insertions(+), 23 deletions(-) diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 2e2ca812eb8..bc832274e64 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -288,7 +288,10 @@ class GrailsBanner implements Banner { } } } - includedVersions.collectEntries { key -> + // A library that is not there, or that records no version, is left out rather than shown + // as unknown. That is what lets a version be on by default: an application without Spring + // Security says nothing about it, instead of saying it does not know. + Map versions = includedVersions.collectEntries { key -> switch (VersionOption.fromString(key)) { case VersionOption.APP: [(env.getProperty('info.app.name') ?: 'app'): env.getProperty('info.app.version') ?: 'unknown'] @@ -312,7 +315,11 @@ class GrailsBanner implements Banner { ['Spring Security': findVersion('org.springframework.security.core.SpringSecurityCoreVersion')] break case VersionOption.TOMCAT: - ['Tomcat': findVersion('org.apache.catalina.util.ServerInfo')] + // Tomcat ships its version in a resource rather than only in a manifest, and a + // resource survives being repackaged into an executable jar or built into an + // image, where the manifest's attributes are no longer attached to the package. + ['Tomcat': findVersionInResource('org/apache/catalina/util/ServerInfo.properties', + 'server.number') ?: findVersion('org.apache.catalina.util.ServerInfo')] break case VersionOption.JETTY: ['Jetty': findVersion('org.eclipse.jetty.util.Jetty')] @@ -324,14 +331,9 @@ class GrailsBanner implements Banner { null } } as Map + versions.findAll { String label, String version -> version != null } } - /** - * Finds the implementation version of the specified class. - * - * @param className the fully qualified class name - * @return the implementation version, or 'unknown' if not found - */ /** * The version a library records in the manifest of the jar it ships in. * @@ -342,12 +344,35 @@ class GrailsBanner implements Banner { * manifest is attached to the package when the class is loaded, and loading is all this * needs.

    */ + /** + * A version a library records in a resource it ships, read without loading any of its classes. + * + *

    The manifest route only works while a jar is a plain entry on the classpath. Repackaged + * into an executable jar its attributes are no longer attached to the package, and an image has + * no jars at all -- which is why a container version read that way reads as nothing in exactly + * the two places it is most worth having. A resource is still a resource in both.

    + */ + protected static String findVersionInResource(String resource, String key) { + InputStream stream = GrailsBanner.classLoader.getResourceAsStream(resource) + if (stream == null) { + return null + } + try { + Properties properties = new Properties() + stream.withCloseable { properties.load(it) } + return properties.getProperty(key) + } + catch (IOException ignored) { + return null + } + } + protected static String findVersion(String className) { try { Package pkg = Class.forName(className, false, GrailsBanner.classLoader).package - return pkg?.implementationVersion ?: 'unknown' + return pkg?.implementationVersion } catch (ClassNotFoundException ignore) { - return 'unknown' + return null } } @@ -521,7 +546,8 @@ class GrailsBanner implements Banner { GRAILS, GROOVY, SPRING_BOOT, - SPRING + SPRING, + SPRING_SECURITY final String key @@ -535,7 +561,6 @@ class GrailsBanner implements Banner { */ @CompileStatic enum OptionalVersionOption { - SPRING_SECURITY, TOMCAT, JETTY, UNDERTOW diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy index 5c03b85fa90..91329dbacff 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy @@ -110,7 +110,7 @@ class GrailsBannerNativeMarkSpec extends Specification { then: output.indexOf('N A T I V E') > output.indexOf('grails.apache.org') - output.indexOf('N A T I V E') < output.indexOf('Grails:') + output.indexOf('N A T I V E') < output.indexOf('JVM') } void 'the mark is centred on the art'() { @@ -164,6 +164,26 @@ class GrailsBannerNativeMarkSpec extends Specification { .contains(AnsiOutput.encode(Ansi8BitColor.foreground(39))) } + void 'spring security is a default rather than something to ask for'() { + expect: 'so an application with it on the classpath shows it without configuring anything' + GrailsBanner.DefaultVersionOption.values()*.key.contains('spring-security') + !GrailsBanner.OptionalVersionOption.values()*.key.contains('spring-security') + } + + void 'a library that is not there is left out rather than shown as unknown'() { + expect: 'jetty and undertow are not on this classpath; asking for them says nothing' + configured(['grails.banner.versions.include': 'jetty,undertow']) + String output = plain(new StartedAs()) + !output.contains('Jetty') + !output.contains('Undertow') + } + + void 'an application can turn spring security off'() { + expect: 'it is a default now, so exclude is what removes it' + configured(['grails.banner.versions.exclude': 'spring-security']) + !plain(new StartedAs()).contains('Spring Security') + } + void 'an application can turn the mark off altogether'() { expect: configured(['grails.banner.mark.display': false]) diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy index 63278d08fd0..6532dd5689a 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy @@ -60,14 +60,14 @@ class GrailsBannerVersionLookupSpec extends Specification { Record.noisyRan } - void 'a library that is not there is unknown rather than an error'() { - expect: - GrailsBanner.findVersion('com.example.NotOnTheClasspath') == 'unknown' + void 'a library that is not there has no version rather than an error'() { + expect: 'nothing, so the banner leaves it out rather than saying it does not know' + GrailsBanner.findVersion('com.example.NotOnTheClasspath') == null } - void 'a library with no version in its manifest is unknown'() { + void 'a library with no version in its manifest has none'() { expect: 'test classes carry no Implementation-Version, and that is not a failure' - GrailsBanner.findVersion(Noisy.name) == 'unknown' + GrailsBanner.findVersion(Noisy.name) == null } void 'a version recorded in a manifest is read'() { diff --git a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc index acd8ed41043..e2e20480c3e 100644 --- a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc +++ b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc @@ -114,16 +114,15 @@ grails: versions: display: true # Whether to display version information (default: true). include: - # Include optional versions (default: []). - # These will trigger class loading to determine the version - # and show 'unknown' if the class is not found. + # Include an optional version (default: []). A library that is not on the classpath, or + # that records no version, is left out rather than shown as unknown -- so including one + # costs nothing where it does not apply. # Valid options are: - - spring-security - tomcat - jetty - undertow exclude: - # Exclude any of the versions included by default (default: []). + # Exclude any of the versions shown by default (default: []). # Valid options are: - app - grails @@ -131,6 +130,7 @@ grails: - jvm - spring-boot - spring + - spring-security order: # Optional ordering in which to display the versions in the banner. # You can specify any number of the options listed below From 199eb8e23eebf1f1752960044ea443a5aa2c8525 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 17:01:04 -0700 Subject: [PATCH 060/115] Show the container being served on, and stop at the first one found Every application runs on a servlet container, so the banner shows it without being asked to. One key, container, covers whichever one it is: an application does not have to know what it is on to be told about it, and moving between them needs no configuration change. An application serves on one container -- choosing another means excluding the starter for this one, so two are not on the classpath together. They are therefore tried in the order they are commonly used, and the first one found is the answer: an application on Tomcat never goes looking for Jetty. The specific names stay available to include, for an application that wants to be told about a particular container whether or not it is the one serving. A container that records no version, or an application on none of these, leaves the line out rather than saying it does not know. --- .../groovy/grails/boot/GrailsBanner.groovy | 69 +++++++++-- .../boot/GrailsBannerNativeMarkSpec.groovy | 8 ++ .../boot/GrailsBannerVersionLookupSpec.groovy | 111 ++++++++++++++++++ .../boot/version-in-a-resource.properties | 5 + .../conf/applicationClass/customizing.adoc | 6 + 5 files changed, 190 insertions(+), 9 deletions(-) create mode 100644 grails-core/src/test/resources/grails/boot/version-in-a-resource.properties diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index bc832274e64..4e4dbbac245 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -263,7 +263,6 @@ class GrailsBanner implements Banner { * @param env the current env * @return a map of version labels to version values */ - @SuppressWarnings('GrMethodMayBeStatic') protected Map createBannerVersions(Environment env) { def defaultIncluded = (DefaultVersionOption.values()).collect { it.key } def sortOrder = findConfiguredVersions(env, 'grails.banner.versions.order') { it in VersionOption.values()*.key } @@ -314,18 +313,17 @@ class GrailsBanner implements Banner { case VersionOption.SPRING_SECURITY: ['Spring Security': findVersion('org.springframework.security.core.SpringSecurityCoreVersion')] break + case VersionOption.CONTAINER: + findContainerVersion() + break case VersionOption.TOMCAT: - // Tomcat ships its version in a resource rather than only in a manifest, and a - // resource survives being repackaged into an executable jar or built into an - // image, where the manifest's attributes are no longer attached to the package. - ['Tomcat': findVersionInResource('org/apache/catalina/util/ServerInfo.properties', - 'server.number') ?: findVersion('org.apache.catalina.util.ServerInfo')] + ['Tomcat': findTomcatVersion()] break case VersionOption.JETTY: - ['Jetty': findVersion('org.eclipse.jetty.util.Jetty')] + ['Jetty': findJettyVersion()] break case VersionOption.UNDERTOW: - ['Undertow': findVersion('io.undertow.Undertow')] + ['Undertow': findUndertowVersion()] break default: null @@ -352,6 +350,53 @@ class GrailsBanner implements Banner { * no jars at all -- which is why a container version read that way reads as nothing in exactly * the two places it is most worth having. A resource is still a resource in both.

    */ + /** + * The servlet container the application is running on, and the version it records. + * + *

    An application runs on one container: choosing another is done by excluding the starter + * for this one, so two are not on the classpath together. They are therefore tried in the order + * they are commonly used and the first one found is the answer -- an application on Tomcat + * never goes looking for Jetty.

    + * + *

    On a container that records no version, or on none of these, this is empty and the banner + * leaves the line out rather than saying it does not know.

    + */ + protected Map findContainerVersion() { + String tomcat = findTomcatVersion() + if (tomcat != null) { + return ['Tomcat': tomcat] + } + String jetty = findJettyVersion() + if (jetty != null) { + return ['Jetty': jetty] + } + String undertow = findUndertowVersion() + if (undertow != null) { + return ['Undertow': undertow] + } + return [:] + } + + /** + * Tomcat's version, read from the resource it ships rather than only from its manifest. + * + *

    A resource survives being repackaged into an executable jar or built into an image, where + * the manifest's attributes are no longer attached to the package -- which is why the manifest + * route reads as nothing in exactly the two places a version is most worth having.

    + */ + protected String findTomcatVersion() { + findVersionInResource('org/apache/catalina/util/ServerInfo.properties', 'server.number') + ?: findVersion('org.apache.catalina.util.ServerInfo') + } + + protected String findJettyVersion() { + findVersion('org.eclipse.jetty.util.Jetty') + } + + protected String findUndertowVersion() { + findVersion('io.undertow.Undertow') + } + protected static String findVersionInResource(String resource, String key) { InputStream stream = GrailsBanner.classLoader.getResourceAsStream(resource) if (stream == null) { @@ -517,6 +562,7 @@ class GrailsBanner implements Banner { SPRING_BOOT, SPRING, SPRING_SECURITY, + CONTAINER, TOMCAT, JETTY, UNDERTOW @@ -547,7 +593,8 @@ class GrailsBanner implements Banner { GROOVY, SPRING_BOOT, SPRING, - SPRING_SECURITY + SPRING_SECURITY, + CONTAINER final String key @@ -558,6 +605,10 @@ class GrailsBanner implements Banner { /** * Enumeration of optional version options. + * + *

    The container being run is shown by default under {@code container}, which is the one an + * application is on. These name a particular container instead, for an application that wants + * to be told about one whether or not it is the one serving.

    */ @CompileStatic enum OptionalVersionOption { diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy index 91329dbacff..94378de0689 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy @@ -170,6 +170,14 @@ class GrailsBannerNativeMarkSpec extends Specification { !GrailsBanner.OptionalVersionOption.values()*.key.contains('spring-security') } + void 'the container served on is a default, and naming a particular one stays optional'() { + expect: 'every application has a container, so it is shown without being asked for' + GrailsBanner.DefaultVersionOption.values()*.key.contains('container') + + and: 'and the specific ones remain, for an application that wants one whatever is serving' + GrailsBanner.OptionalVersionOption.values()*.key == ['tomcat', 'jetty', 'undertow'] + } + void 'a library that is not there is left out rather than shown as unknown'() { expect: 'jetty and undertow are not on this classpath; asking for them says nothing' configured(['grails.banner.versions.include': 'jetty,undertow']) diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy index 6532dd5689a..30e18ac581d 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy @@ -18,6 +18,8 @@ */ package grails.boot +import org.springframework.core.env.MapPropertySource +import org.springframework.core.env.StandardEnvironment import spock.lang.Specification /** @@ -74,4 +76,113 @@ class GrailsBannerVersionLookupSpec extends Specification { expect: 'Spock ships one, so this proves the lookup reads rather than always saying unknown' GrailsBanner.findVersion(Specification.name) ==~ /\d+\..*/ } + + void 'a version recorded in a resource is read'() { + expect: 'the route a container version takes, which a manifest cannot take out of a jar' + GrailsBanner.findVersionInResource('grails/boot/version-in-a-resource.properties', + 'server.number') == '1.2.3' + } + + void 'a resource that is not there has no version rather than an error'() { + expect: + GrailsBanner.findVersionInResource('grails/boot/no-such-resource.properties', + 'server.number') == null + } + + void 'a resource that records no such version has none'() { + expect: 'a library may ship the file and still not answer this question' + GrailsBanner.findVersionInResource('grails/boot/version-in-a-resource.properties', + 'server.unrecorded') == null + } + + /** A banner told which containers are there, and remembering which it was asked about. */ + static class Serving extends GrailsBanner { + + Map present = [:] + + List asked = [] + + @Override + protected String findTomcatVersion() { + asked << 'tomcat' + present['tomcat'] + } + + @Override + protected String findJettyVersion() { + asked << 'jetty' + present['jetty'] + } + + @Override + protected String findUndertowVersion() { + asked << 'undertow' + present['undertow'] + } + } + + private static StandardEnvironment configured(Map properties = [:]) { + StandardEnvironment environment = new StandardEnvironment() + environment.propertySources.addFirst(new MapPropertySource('test', properties)) + environment + } + + void 'the container being served on is shown, named as itself'() { + expect: + new Serving(present: ['tomcat': '1.1.1']).findContainerVersion() == ['Tomcat': '1.1.1'] + } + + void 'the ones it cannot also be running on are not looked for'() { + given: 'an application serves on one container, so the second is not a question worth asking' + Serving banner = new Serving(present: ['tomcat': '1.1.1', 'jetty': '2.2.2']) + + when: + Map container = banner.findContainerVersion() + + then: 'the most commonly used of the two, and only that one shown' + container == ['Tomcat': '1.1.1'] + + and: 'and only that one asked about' + banner.asked == ['tomcat'] + } + + void 'the next one is tried when the one before it is not there'() { + expect: + new Serving(present: ['jetty': '2.2.2']).findContainerVersion() == ['Jetty': '2.2.2'] + new Serving(present: ['undertow': '3.3.3']).findContainerVersion() == ['Undertow': '3.3.3'] + } + + void 'an application on none of them says nothing rather than that it does not know'() { + when: + Serving banner = new Serving() + + then: + banner.findContainerVersion().isEmpty() + + and: 'having asked about each, since any of them could have been the one' + banner.asked == ['tomcat', 'jetty', 'undertow'] + } + + void 'the container is shown without an application asking for it'() { + expect: + new Serving(present: ['tomcat': '1.1.1']).createBannerVersions(configured())['Tomcat'] == '1.1.1' + } + + void 'an application can leave the container out'() { + expect: 'one key covers whichever container it is, so this is how it is turned off' + !new Serving(present: ['tomcat': '1.1.1']) + .createBannerVersions(configured(['grails.banner.versions.exclude': 'container'])) + .containsKey('Tomcat') + } + + void 'naming the container as well as being shown it by default shows it once'() { + when: 'an application that asked for tomcat before it was shown by default keeps working' + Serving banner = new Serving(present: ['tomcat': '1.1.1']) + ByteArrayOutputStream bytes = new ByteArrayOutputStream() + banner.printBanner(configured(['grails.banner.versions.include': 'tomcat']), + GrailsBannerVersionLookupSpec, new PrintStream(bytes)) + + then: + bytes.toString().count('Tomcat') == 1 + } } diff --git a/grails-core/src/test/resources/grails/boot/version-in-a-resource.properties b/grails-core/src/test/resources/grails/boot/version-in-a-resource.properties new file mode 100644 index 00000000000..147708d0c3e --- /dev/null +++ b/grails-core/src/test/resources/grails/boot/version-in-a-resource.properties @@ -0,0 +1,5 @@ +# Stands in for a library that records its version in a resource it ships, the way Tomcat records +# its own in org/apache/catalina/util/ServerInfo.properties. Kept here rather than read from a real +# dependency so that the test does not change meaning when a managed version is bumped. +server.number=1.2.3 +server.built=not a version diff --git a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc index e2e20480c3e..009af0509fc 100644 --- a/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc +++ b/grails-doc/src/en/guide/conf/applicationClass/customizing.adoc @@ -117,12 +117,16 @@ grails: # Include an optional version (default: []). A library that is not on the classpath, or # that records no version, is left out rather than shown as unknown -- so including one # costs nothing where it does not apply. + # The container being served on is already shown by default, under 'container'. These name + # a particular one instead, for an application that wants to be told about it whether or + # not it is the one serving. # Valid options are: - tomcat - jetty - undertow exclude: # Exclude any of the versions shown by default (default: []). + # Use 'container' to leave out the servlet container, whichever one it is. # Valid options are: - app - grails @@ -131,6 +135,7 @@ grails: - spring-boot - spring - spring-security + - container order: # Optional ordering in which to display the versions in the banner. # You can specify any number of the options listed below @@ -143,6 +148,7 @@ grails: - spring-boot - spring - spring-security + - container - tomcat - jetty - undertow From 223ac95f2662081dfa849d12af2d81df6ba5a0a2 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 17:04:07 -0700 Subject: [PATCH 061/115] Build on JDK 21.0.12 The pinned JDK moves in four places at once. A release is built to be reproducible, which means the JDK is part of what is being pinned: the version in .sdkmanrc, the one the release workflows install, and the one the verification container is built from all have to be the same, or a rebuild of a release does not produce the release. grails-test-examples/gsp-spring-boot keeps its own, older toolchain and is not part of this set. --- .github/workflows/release-publish-docs.yml | 2 +- .github/workflows/release.yml | 2 +- .sdkmanrc | 2 +- etc/bin/Dockerfile | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/release-publish-docs.yml b/.github/workflows/release-publish-docs.yml index b4820647804..73f1ae939dc 100644 --- a/.github/workflows/release-publish-docs.yml +++ b/.github/workflows/release-publish-docs.yml @@ -25,7 +25,7 @@ permissions: { } env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} JAVA_DISTRIBUTION: liberica - JAVA_VERSION: 21.0.7 + JAVA_VERSION: 21.0.12 TARGET_BRANCH: ${{ github.ref_name }} VERSION: ${{ inputs.version }} jobs: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index e6762cb9b84..b044f6d0830 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -24,7 +24,7 @@ env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} GRAILS_PUBLISH_RELEASE: 'true' JAVA_DISTRIBUTION: liberica - JAVA_VERSION: 21.0.7 # this must be a specific version for reproducible builds, keep it synced with .sdkmanrc and verification container + JAVA_VERSION: 21.0.12 # this must be a specific version for reproducible builds, keep it synced with .sdkmanrc and verification container JAVA_VERSION_MICRONAUT: 25.0.3 # the Grails-Micronaut "island" (grails-micronaut, grails-micronaut-bom) is built against Micronaut 5 which targets JVM 25 bytecode. Keep this synced with the secondary JDK installed in etc/bin/Dockerfile and the JDK_25_HOME branch in etc/bin/verify-reproducible.sh. PROJECT_DESC: > Grails is a powerful Groovy-based web application framework for the JVM, diff --git a/.sdkmanrc b/.sdkmanrc index 508f113b0c1..8a8e9095b8d 100644 --- a/.sdkmanrc +++ b/.sdkmanrc @@ -5,7 +5,7 @@ # $JAVA_VERSION_MICRONAUT in release.yml; for local verification, install that JDK 25 # alongside this one (sdk install java -librca) and follow the dual-JDK # instructions in RELEASE.md "Manual Verification: Reproducible Jar Files". -java=21.0.7-librca +java=21.0.12-librca # Keep gradle version synced with gradle.properties (gradleToolingApiVersion). # Update the gradle-bootstrap project to propagate the version to all gradle-wrapper.properties files. gradle=9.6.0 diff --git a/etc/bin/Dockerfile b/etc/bin/Dockerfile index fe376a6da81..345396ad874 100644 --- a/etc/bin/Dockerfile +++ b/etc/bin/Dockerfile @@ -17,7 +17,7 @@ # run this from the root of the project # `docker build -t grails:testing -f etc/bin/Dockerfile . && docker run -it --rm -v $(pwd):/home/groovy/project grails:testing bash` # Keep java version synced with .sdkmanrc and .github/workflows/release.yml ($JAVA_VERSION) -FROM bellsoft/liberica-openjdk-debian:21.0.7 +FROM bellsoft/liberica-openjdk-debian:21.0.12 USER root RUN apt-get update && apt-get install -y ca-certificates curl unzip coreutils libdigest-sha-perl gpg vim sudo psmisc locales groovy rsync nano From bd86459603cf986eeec8b09390e3c3e4a2671852 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 19:02:30 -0700 Subject: [PATCH 062/115] Give an application building ahead of time what it needs Two things a Grails application needs that neither Spring nor GraalVM can work out for it, and that every application building an image or a cache had to write for itself. An image includes what it can prove is reached. Resources are reached by name at run time -- a compiled asset by request path, a message bundle by locale -- so nothing proves they are needed and the image is built without them. The application starts and then serves every page with a missing stylesheet and an untranslated string. Generating bean definitions reads the ones the application declares, and an application declares different ones in different environments: development declares reloadable beans, which cannot be written out as code. Left at the default, what is generated is development's, and what is built is not the application that was asked for. Both are reactions to a plugin the application applied. Applying GraalVM's plugin is already how an application says it wants an image, and Spring Boot's AOT plugin is how it asks for generated definitions -- so neither needs a setting of its own, and an application that applies neither reaches none of this and sees no change at all. Invokedynamic is a convention rather than a decision: an image cannot define the class a classic call site defines as it runs, so it is on by default where an image is being built, and an application that has said otherwise keeps what it said. --- .../plugin/core/GrailsGradlePlugin.groovy | 67 ++++++++++++++++ .../core/GrailsNativeImageDefaultsSpec.groovy | 76 +++++++++++++++++++ .../native-defaults-aot/build.gradle | 10 +++ .../native-defaults-aot/gradle.properties | 1 + .../grails-app/conf/application.yml | 0 .../native-defaults-aot/settings.gradle | 1 + .../native-defaults-off/build.gradle | 12 +++ .../native-defaults-off/gradle.properties | 1 + .../grails-app/conf/application.yml | 0 .../native-defaults-off/settings.gradle | 1 + .../native-defaults-on/build.gradle | 13 ++++ .../native-defaults-on/gradle.properties | 1 + .../grails-app/conf/application.yml | 0 .../native-defaults-on/settings.gradle | 1 + 14 files changed, 184 insertions(+) create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/build.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/gradle.properties create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/grails-app/conf/application.yml create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/settings.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/build.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/gradle.properties create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/grails-app/conf/application.yml create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/settings.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/gradle.properties create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/grails-app/conf/application.yml create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/settings.gradle diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index fd2f131738b..af20ee8cdde 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -168,6 +168,10 @@ class GrailsGradlePlugin implements Plugin { configureBootRunPidFile(project) + configureAheadOfTimeProcessing(project) + + configureNativeImage(project) + configureJavaCompatibilityArgs(project) configureGrailsSourceDirs(project) @@ -943,6 +947,69 @@ ${importStatements} configureToolchainForForkTasks(project) } + /** + * Generates the application's bean definitions for the environment it will be run in. + * + *

    Generation reads the definitions to write them out as code, and an application declares + * different ones in different environments -- development declares reloadable beans, which + * cannot be expressed as generated code. Left at the default the definitions written out are + * development's, and an application built from them is not the application that was asked + * for.

    + * + *

    Nothing here runs unless the application applies Spring Boot's AOT plugin, which is what + * asks for generated definitions in the first place.

    + */ + protected void configureAheadOfTimeProcessing(Project project) { + project.pluginManager.withPlugin('org.springframework.boot.aot') { + project.tasks.named('processAot', JavaExec) { JavaExec task -> + task.systemProperty(Environment.KEY, Environment.PRODUCTION.name) + } + } + } + + /** + * What a Grails application needs of a native image that an image cannot work out for itself. + * + *

    An image includes what it can prove is reached. Resources are reached by name at run time + * -- a compiled asset by request path, a message bundle by locale -- so nothing proves they are + * needed and an image is built without them: the application starts and then answers every + * page with a missing stylesheet and an untranslated string.

    + * + *

    Applications resolve calls through invokedynamic here, because the classic call site + * defines a class as it runs and an image has no way to define one. The framework has to be + * built the same way. This is a convention, so an application that has said otherwise keeps + * what it said.

    + * + *

    Nothing here runs unless the application applies GraalVM's plugin, which is what asks for + * an image in the first place. An application that never builds one is untouched.

    + */ + protected void configureNativeImage(Project project) { + project.pluginManager.withPlugin('org.graalvm.buildtools.native') { + GrailsExtension grailsExt = project.extensions.getByType(GrailsExtension) + grailsExt.indy.convention(true) + addNativeImageResources(project) + } + } + + /** + * Adds the resource patterns above to the image being built. + * + *

    Configured dynamically because the extension's type ships with GraalVM's plugin, which is + * not a dependency of this one -- an application that never builds an image should not have to + * resolve it. This only runs where that plugin has been applied, so the extension is there.

    + */ + @CompileDynamic + protected void addNativeImageResources(Project project) { + Object graalvmNative = project.extensions.findByName('graalvmNative') + if (graalvmNative == null) { + return + } + graalvmNative.binaries.named('main') { binary -> + binary.buildArgs.add('-H:IncludeResources=assets/.*') + binary.buildArgs.add('-H:IncludeResources=.*[.]properties') + } + } + protected void configureBootRunPidFile(Project project) { // Producer side of the run-app PID contract: the forked app writes its PID to 'run-app.pid' // under the Gradle build directory. The CLI stop-app command resolves the PID file diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy new file mode 100644 index 00000000000..1199247c504 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy @@ -0,0 +1,76 @@ +/* + * 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.grails.gradle.plugin.core + +import org.gradle.testkit.runner.BuildResult + +/** + * Covers what an application gets for building a native image, and what it does not get for not + * building one. + * + *

    These are reactions to the plugin the application applied, not a setting it has to find. + * Applying GraalVM's plugin is already how an application says it wants an image; nothing here is + * reached without it, so an application that has no use for any of it pays nothing and sees no + * change.

    + * + * @since 8.0 + * @see GrailsGradlePlugin#configureNativeImage + */ +class GrailsNativeImageDefaultsSpec extends GradleSpecification { + + void 'an application that builds no image is left as it was'() { + given: + setupTestResourceProject('native-defaults-off') + + when: + BuildResult result = executeTask('inspectDefaults') + + then: 'invokedynamic stays off, as it is for every application that did not ask for it' + result.output.contains('INDY=false') + + and: 'and nothing an image would want has been added' + result.output.contains('HAS_NATIVE_EXTENSION=false') + } + + void 'definitions are generated for the environment the application will run in'() { + given: 'the plugin that asks for generated definitions is what this reacts to' + setupTestResourceProject('native-defaults-aot') + + when: + BuildResult result = executeTask('inspectAot') + + then: 'development declares reloadable beans, which cannot be written out as code' + result.output.contains('GRAILS_ENV=production') + } + + void 'an application that builds an image gets what an image needs'() { + given: + setupTestResourceProject('native-defaults-on') + + when: + BuildResult result = executeTask('inspectDefaults') + + then: 'a classic call site defines a class as it runs, which an image has no way to do' + result.output.contains('INDY=true') + + and: 'nothing proves a stylesheet or a message bundle is reached, so nothing includes them' + result.output.contains('HAS_ASSETS=true') + result.output.contains('HAS_PROPERTIES=true') + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/build.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/build.gradle new file mode 100644 index 00000000000..f85514c8a29 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/build.gradle @@ -0,0 +1,10 @@ +plugins { + id 'org.apache.grails.gradle.grails-app' + id 'org.springframework.boot.aot' +} + +tasks.register('inspectAot') { + doLast { + println "GRAILS_ENV=${tasks.named('processAot').get().systemProperties['grails.env']}" + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/gradle.properties b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/gradle.properties new file mode 100644 index 00000000000..35c332fb874 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/gradle.properties @@ -0,0 +1 @@ +grailsVersion=__PROJECT_VERSION__ diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/grails-app/conf/application.yml b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/grails-app/conf/application.yml new file mode 100644 index 00000000000..e69de29bb2d diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/settings.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/settings.gradle new file mode 100644 index 00000000000..04f5f689a93 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-aot/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'native-defaults-aot' diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/build.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/build.gradle new file mode 100644 index 00000000000..aa04269ab4e --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/build.gradle @@ -0,0 +1,12 @@ +plugins { + id 'org.apache.grails.gradle.grails-app' +} + +// An application that builds neither an image nor a cache applies neither plugin, and so should +// find nothing has been decided on its behalf. +tasks.register('inspectDefaults') { + doLast { + println "INDY=${project.extensions.getByName('grails').indy.get()}" + println "HAS_NATIVE_EXTENSION=${project.extensions.findByName('graalvmNative') != null}" + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/gradle.properties b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/gradle.properties new file mode 100644 index 00000000000..35c332fb874 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/gradle.properties @@ -0,0 +1 @@ +grailsVersion=__PROJECT_VERSION__ diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/grails-app/conf/application.yml b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/grails-app/conf/application.yml new file mode 100644 index 00000000000..e69de29bb2d diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/settings.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/settings.gradle new file mode 100644 index 00000000000..0a4b1dcc6ac --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-off/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'native-defaults-off' diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle new file mode 100644 index 00000000000..2d1dcee00b2 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle @@ -0,0 +1,13 @@ +plugins { + id 'org.apache.grails.gradle.grails-app' + id 'org.graalvm.buildtools.native' version '1.1.7' +} + +tasks.register('inspectDefaults') { + doLast { + def args = project.extensions.getByName('graalvmNative').binaries.getByName('main').buildArgs.get() + println "INDY=${project.extensions.getByName('grails').indy.get()}" + println "HAS_ASSETS=${args.contains('-H:IncludeResources=assets/.*')}" + println "HAS_PROPERTIES=${args.contains('-H:IncludeResources=.*[.]properties')}" + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/gradle.properties b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/gradle.properties new file mode 100644 index 00000000000..35c332fb874 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/gradle.properties @@ -0,0 +1 @@ +grailsVersion=__PROJECT_VERSION__ diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/grails-app/conf/application.yml b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/grails-app/conf/application.yml new file mode 100644 index 00000000000..e69de29bb2d diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/settings.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/settings.gradle new file mode 100644 index 00000000000..8012c888a5d --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'native-defaults-on' From f18532d7f8fffea49baca1ce9cf12f4e1a04a223 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 22:04:12 -0700 Subject: [PATCH 063/115] Space a mark as it was written rather than shouting it The mark was upper cased on its way out, which the three it works out for itself did not need -- they are written that way -- and which took something away from the one an application supplies: a name whose case is part of it, CRaC, came out as CRAC, and an application asking for Leyden was answered LEYDEN. --- .../main/groovy/grails/boot/GrailsBanner.groovy | 10 ++++++++-- .../grails/boot/GrailsBannerNativeMarkSpec.groovy | 14 +++++++++++++- 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index 4e4dbbac245..f1a9be076b4 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -165,9 +165,15 @@ class GrailsBanner implements Banner { } } - /** Spaced so it reads as a mark rather than a word. */ + /** + * Spaced so it reads as a mark rather than a word. + * + *

    Spaced as written rather than shouted: the marks this draws are already upper case, and + * an application that says what it wants the mark to be gets what it said. A name whose case + * is part of it -- CRaC -- keeps it.

    + */ private static String spaced(String word) { - word.toUpperCase().toCharArray().join(' ') + word.toCharArray().join(' ') } /** Whether this is running as an image. A seam, so the mark can be covered without being one. */ diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy index 94378de0689..74e201f5fd4 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy @@ -137,7 +137,19 @@ class GrailsBannerNativeMarkSpec extends Specification { void 'an application can say something else'() { expect: configured(['grails.banner.mark.text': 'Leyden']) - plain(new StartedAs(cache: true)).contains('L E Y D E N') + plain(new StartedAs(cache: true)).contains('L e y d e n') + } + + void 'a mark is spaced as it was written rather than shouted'() { + expect: 'a name whose case is part of it keeps it -- CRaC is not CRAC' + configured(['grails.banner.mark.text': 'CRaC']) + plain(new StartedAs()).contains('C R a C') + } + + void 'the marks it works out for itself are still upper case'() { + expect: 'they are written that way, rather than made that way' + plain(new StartedAs(image: true)).contains('N A T I V E') + plain(new StartedAs(cache: true)).contains('A O T C A C H E') } void 'the mark is a different colour from the art'() { From 61d90312d6d98592f6d6a7ca1950a9bd1acfd7d0 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 7 Aug 2026 23:18:13 -0700 Subject: [PATCH 064/115] Register an image's resources as hints rather than as build arguments An image includes what it can prove is reached. Resources are reached by name at run time -- a compiled asset by request path, a message bundle by locale -- so nothing proves they are needed and an image is built without them: it starts and then serves every page with a missing stylesheet and an untranslated string. They were named with -H:IncludeResources, which GraalVM now warns about twice on every build: the option is experimental and will have to be unlocked. Hints are the supported way, and are what Spring writes an image's resource configuration from -- so this moves out of the Gradle plugin, which was passing build arguments, and into the framework beside the hints already registered there. --- .../beans/aot/GrailsResourceRuntimeHints.java | 53 +++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 1 + .../plugin/core/GrailsGradlePlugin.groovy | 25 --------- .../core/GrailsNativeImageDefaultsSpec.groovy | 4 -- .../native-defaults-on/build.gradle | 3 -- 5 files changed, 54 insertions(+), 32 deletions(-) create mode 100644 grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java new file mode 100644 index 00000000000..5bdd40f3295 --- /dev/null +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java @@ -0,0 +1,53 @@ +/* + * 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.grails.spring.beans.aot; + +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * The resources a Grails application reads by name at run time, which an image cannot prove are + * reached. + * + *

    An image includes what it can prove is used. A compiled asset is asked for by request path and + * a message bundle by locale, so nothing in the code names either, and an image built without them + * starts and then serves every page with a missing stylesheet and an untranslated string.

    + * + *

    Registered as hints rather than passed as {@code -H:IncludeResources}: that option is + * experimental and GraalVM now warns it will require unlocking, while hints are the supported way + * and are what Spring writes the image's resource configuration from.

    + * + * @since 8.0 + */ +public class GrailsResourceRuntimeHints implements RuntimeHintsRegistrar { + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + // Compiled assets, which asset-pipeline serves from the classpath by the path asked for. + hints.resources().registerPattern("assets/*"); + hints.resources().registerPattern("assets/**"); + + // Message bundles, chosen by the locale of the request. At the root of the classpath and, + // for a plugin that ships its own, below it. + hints.resources().registerPattern("*.properties"); + hints.resources().registerPattern("**/*.properties"); + } + +} diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index 6e31fadd544..fe2a8c4bea9 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -6,6 +6,7 @@ org.grails.spring.beans.aot.BeanRegistrarRuntimeHints,\ org.grails.spring.beans.aot.GrailsApiRuntimeHints,\ org.grails.spring.beans.aot.GrailsBannerRuntimeHints,\ org.grails.spring.beans.aot.GrailsClosureRuntimeHints,\ +org.grails.spring.beans.aot.GrailsResourceRuntimeHints,\ org.grails.spring.beans.aot.GroovyExtensionModuleRuntimeHints org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index af20ee8cdde..9e9b3ff2c24 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -970,11 +970,6 @@ ${importStatements} /** * What a Grails application needs of a native image that an image cannot work out for itself. * - *

    An image includes what it can prove is reached. Resources are reached by name at run time - * -- a compiled asset by request path, a message bundle by locale -- so nothing proves they are - * needed and an image is built without them: the application starts and then answers every - * page with a missing stylesheet and an untranslated string.

    - * *

    Applications resolve calls through invokedynamic here, because the classic call site * defines a class as it runs and an image has no way to define one. The framework has to be * built the same way. This is a convention, so an application that has said otherwise keeps @@ -987,26 +982,6 @@ ${importStatements} project.pluginManager.withPlugin('org.graalvm.buildtools.native') { GrailsExtension grailsExt = project.extensions.getByType(GrailsExtension) grailsExt.indy.convention(true) - addNativeImageResources(project) - } - } - - /** - * Adds the resource patterns above to the image being built. - * - *

    Configured dynamically because the extension's type ships with GraalVM's plugin, which is - * not a dependency of this one -- an application that never builds an image should not have to - * resolve it. This only runs where that plugin has been applied, so the extension is there.

    - */ - @CompileDynamic - protected void addNativeImageResources(Project project) { - Object graalvmNative = project.extensions.findByName('graalvmNative') - if (graalvmNative == null) { - return - } - graalvmNative.binaries.named('main') { binary -> - binary.buildArgs.add('-H:IncludeResources=assets/.*') - binary.buildArgs.add('-H:IncludeResources=.*[.]properties') } } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy index 1199247c504..e95110ef648 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy @@ -68,9 +68,5 @@ class GrailsNativeImageDefaultsSpec extends GradleSpecification { then: 'a classic call site defines a class as it runs, which an image has no way to do' result.output.contains('INDY=true') - - and: 'nothing proves a stylesheet or a message bundle is reached, so nothing includes them' - result.output.contains('HAS_ASSETS=true') - result.output.contains('HAS_PROPERTIES=true') } } diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle index 2d1dcee00b2..8c7467cf904 100644 --- a/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-defaults-on/build.gradle @@ -5,9 +5,6 @@ plugins { tasks.register('inspectDefaults') { doLast { - def args = project.extensions.getByName('graalvmNative').binaries.getByName('main').buildArgs.get() println "INDY=${project.extensions.getByName('grails').indy.get()}" - println "HAS_ASSETS=${args.contains('-H:IncludeResources=assets/.*')}" - println "HAS_PROPERTIES=${args.contains('-H:IncludeResources=.*[.]properties')}" } } From fe4c9cfc2e688f446a06dcb7ffd44955af14f719 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 09:50:07 -0700 Subject: [PATCH 065/115] Stop caching what a forked compiler produced Compiling pages is forked, and what comes out depends on which Groovy and which Java did it. Neither is described by this task's inputs, so Gradle handed one build's pages to another that wanted different ones. An application building a native image resolves Groovy 6 and builds for JDK 25; one training an AOT cache resolves Groovy 5 and builds for a later JDK. Cached, the first build's pages were restored into the second and failed at the moment a page was first rendered: BUG! your call tried to do a property set, which is not supported at gsp_appindex_gsp.init(gsp_appindex_gsp.groovy) and, before that, an UnsupportedClassVersionError -- both long after the build said it had succeeded, and both surviving a clean, which is what made them hard to place. Declaring the launcher an input was not enough: it says which Java runs the fork, not which Groovy the fork compiles against, and the evidence is that it did not reach the key either. Compiling the pages again costs seconds. --- .../views/gsp/GroovyPageForkCompileTask.groovy | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy index c9f181895d2..522baf4db9c 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy @@ -34,7 +34,6 @@ import org.gradle.api.file.DirectoryProperty import org.gradle.api.file.FileTree import org.gradle.api.model.ObjectFactory import org.gradle.api.provider.Property -import org.gradle.api.tasks.CacheableTask import org.gradle.api.tasks.Input import org.gradle.api.tasks.InputDirectory import org.gradle.api.tasks.InputFiles @@ -46,6 +45,7 @@ import org.gradle.api.tasks.PathSensitive import org.gradle.api.tasks.PathSensitivity import org.gradle.api.tasks.TaskAction import org.gradle.api.tasks.compile.AbstractCompile +import org.gradle.work.DisableCachingByDefault import org.gradle.process.ExecOperations import org.gradle.process.ExecResult import org.gradle.process.JavaExecSpec @@ -60,8 +60,19 @@ import org.grails.gradle.plugin.views.ViewCompileOptions * @author David Estes * @since 4.0 */ +/** + * Not cacheable. A page is compiled by a forked Groovy, and what comes out depends on which Groovy + * and which Java did it -- neither of which this task's inputs describe: an application building a + * native image resolves Groovy 6 and builds for JDK 25, and one training a cache resolves Groovy 5 + * and builds for a later JDK. Cached, the first build's pages were handed to the second, which + * failed at the moment a page was first rendered, with + * {@code BUG! your call tried to do a property set} or an + * {@code UnsupportedClassVersionError} -- long after the build said it had succeeded. + * + *

    Compiling them again costs seconds. Getting this wrong costs an afternoon.

    + */ @CompileStatic -@CacheableTask +@DisableCachingByDefault(because = 'What a forked compiler produces is not described by this task\'s inputs') abstract class GroovyPageForkCompileTask extends AbstractCompile { @Input From baf640289e9f7ca6c74f7d1bc7c45975b5fbb387 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 15:06:59 -0700 Subject: [PATCH 066/115] Say how the extracted application is compared, so the task validates Gradle refuses to validate a task whose directory input does not say how its path is to be treated, and validatePlugins fails on this branch for that alone -- an @InputDirectory with no normalization strategy. The extracted application is compared by what is in it and where each file sits within it, not by where the directory itself is. Left unsaid, the absolute path counts as part of the input, so the same application checked out under another name, or built on CI, would agree about everything and still share nothing. --- .../gradle/plugin/aot/TrainAotCacheTask.groovy | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index 3911c063ddd..cce4020c149 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -31,6 +31,8 @@ import org.gradle.api.provider.Property import org.gradle.api.tasks.Input import org.gradle.api.tasks.InputDirectory import org.gradle.api.tasks.OutputFile +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity import org.gradle.api.tasks.TaskAction import org.gradle.work.DisableCachingByDefault @@ -52,8 +54,17 @@ import org.gradle.work.DisableCachingByDefault @DisableCachingByDefault(because = 'Runs the application and records what it did, which is not reproducible') abstract class TrainAotCacheTask extends DefaultTask { - /** The extracted application: the cache is only usable against the layout it was trained on. */ + /** + * The extracted application: the cache is only usable against the layout it was trained on. + * + *

    Compared by what is in it and where each file sits within it, not by where the directory + * itself is. Without saying so, Gradle takes the absolute path to be part of the input and + * refuses to validate the task at all -- and a build that did run would key its result to a + * path, so the same application checked out somewhere else, or built on CI, would agree about + * everything and still share nothing.

    + */ @InputDirectory + @PathSensitive(PathSensitivity.RELATIVE) abstract DirectoryProperty getApplicationDirectory() @Input From 184821249d1d5646e66ee86a578fd3729c458587 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 14:49:03 -0700 Subject: [PATCH 067/115] Say why the training run ended, not only that it did A training run that cannot start fails the build with "The training run ended before it started serving" and the path to a log. The log is eighty lines of banner, plugin list and class names, and the reason is four of them somewhere in the middle. The reason is what someone reading a failed build needs. One of these turned out to be an environment variable that Spring binds over the application's own configuration -- GRAILS_MONGODB_URL, empty, reaching the run because the training JVM inherits the Gradle daemon's environment and the daemon's environment is not the one the build was started from. Nothing in the build output said so; it said a run had ended. Spring Boot already prints why it could not start. This puts those lines in the failure that reports it, without the box they were printed in, and reads the log defensively: a log that cannot be read is no reason to lose the failure already being reported. --- .../plugin/aot/TrainAotCacheTask.groovy | 36 +++++++++++++++- .../plugin/aot/TrainAotCacheTaskSpec.groovy | 43 +++++++++++++++++++ 2 files changed, 77 insertions(+), 2 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index cce4020c149..9a7f0ddbb8d 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -204,8 +204,8 @@ abstract class TrainAotCacheTask extends DefaultTask { long deadline = System.currentTimeMillis() + Duration.ofSeconds(startTimeoutSeconds.get()).toMillis() while (System.currentTimeMillis() < deadline) { if (!process.isAlive()) { - throw new GradleException('The training run ended before it started serving. ' + - "What it printed is in ${output}") + throw new GradleException('The training run ended before it started serving.' + + whyItEnded(output) + " What it printed is in ${output}") } if (output.isFile() && output.text.contains('Started ')) { return @@ -219,6 +219,38 @@ abstract class TrainAotCacheTask extends DefaultTask { "What it printed is in ${output}") } + /** + * What the run said was wrong, for the message that reports it ended. + * + *

    Spring Boot prints why it could not start, and the reason is what someone reading a failed + * build needs -- the build said only that the run had ended and named a file, and finding out + * that an environment variable had quietly replaced a configured property meant reading a log + * that scrolls for eighty lines and is mostly a banner and a class list.

    + * + *

    Read defensively: this runs while reporting a failure, and a log that cannot be read is no + * reason to lose the failure that was already being reported.

    + */ + private static String whyItEnded(File output) { + List reason = [] + try { + if (output.isFile()) { + List lines = output.readLines() + int failed = lines.findLastIndexOf { String line -> line.contains('APPLICATION FAILED TO START') } + if (failed >= 0) { + // Description, then the reason under it, without the box drawing or the blank lines. + reason = lines[failed.. line.replaceAll(/\[[0-9;]*m/, '').trim() } + .findAll { String line -> line && !(line ==~ /[*]+/) && line != 'APPLICATION FAILED TO START' } + .take(4) + } + } + } + catch (IOException ignored) { + return '' + } + reason ? "\n\n${reason.join('\n')}\n" : '' + } + /** Whether anything is accepting connections on the port the run was told to listen on. */ private boolean serving() { try { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index e812bd72a9f..08b946802cf 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -143,6 +143,49 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ new File(e.message.replaceAll(/(?s).*is in /, '').trim()).isFile() } + void 'a run that could not start is reported with what it said was wrong'() { + given: 'a run that prints why it could not start, the way Spring Boot does, and ends' + File application = new File(temporaryFolder, 'failing') + application.mkdirs() + new File(application, 'failing.jar').text = 'stands in for the archive' + File script = new File(temporaryFolder, 'failing-jvm.sh') + script.text = '''#!/bin/sh +echo "***************************" +echo "APPLICATION FAILED TO START" +echo "***************************" +echo "" +echo "Description:" +echo "" +echo "Invalid value for configuration property grails.mongodb.url, originating from System Environment Property GRAILS_MONGODB_URL" +exit 1 +''' + script.setExecutable(true) + TrainAotCacheTask task = project.tasks.create('trainFailing', TrainAotCacheTask) + task.applicationDirectory.set(application) + task.archiveFileName.set('failing.jar') + task.cacheFile.set(new File(application, 'demo.aot')) + task.metadataFile.set(new File(application, 'aot-cache.properties')) + task.javaExecutable.set(script.absolutePath) + task.javaVersion.set('25.0.1+9') + task.javaVendor.set('A Vendor') + task.jvmArguments.set([]) + task.paths.set([]) + task.port.set(18097) + task.startTimeoutSeconds.set(5) + + when: + task.train() + + then: 'the reason is in the failure, rather than only a file to go and read' + GradleException e = thrown() + e.message.contains('ended before it started serving') + e.message.contains('grails.mongodb.url') + e.message.contains('GRAILS_MONGODB_URL') + + and: 'without the box it was printed in' + !e.message.contains('****') + } + void 'a run that starts is exercised and described'() { given: 'a run that says it started, serves what it is asked for, and stops when asked' TrainAotCacheTask task = servingTask(['/', '/login', '/missing']) From c465952f53161be3a046e553c34afaf34601702c Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 17:02:50 -0700 Subject: [PATCH 068/115] Do not hand the training run a variable the daemon kept but emptied The training run inherits the Gradle daemon's environment, and the daemon's is not the environment the build was started from. A daemon that once ran a build with a variable set keeps the name after that build has finished and empties the value, so a later build, started from a shell that never mentioned it, hands the run SOME_VARIABLE="" all the same. Spring Boot binds an environment variable over the application's own configuration, and relaxed binding makes GRAILS_MONGODB_URL into grails.mongodb.url. So an application that had configured its database correctly failed to start, reporting an invalid empty value against a property name nobody had typed -- and only in the training run, only after some earlier build in the same daemon had set that variable, and never when run by hand. Stopping the daemon fixed it, which made it look intermittent for a long time. An empty variable says nothing an absent one does not, so it is not passed on. What the build was actually given still arrives; only what the daemon kept afterwards is dropped. --- grails-gradle/plugins/build.gradle | 7 +++ .../plugin/aot/TrainAotCacheTask.groovy | 29 ++++++++++++- .../plugin/aot/TrainAotCacheTaskSpec.groovy | 43 +++++++++++++++++++ 3 files changed, 77 insertions(+), 2 deletions(-) diff --git a/grails-gradle/plugins/build.gradle b/grails-gradle/plugins/build.gradle index 198315c2fc6..0e735ef39e0 100644 --- a/grails-gradle/plugins/build.gradle +++ b/grails-gradle/plugins/build.gradle @@ -189,3 +189,10 @@ apply { from rootProject.layout.projectDirectory.file('gradle/docs-config.gradle') from rootProject.layout.projectDirectory.file('gradle/test-config.gradle') } + +// A variable that is present and empty, which is what a Gradle daemon keeps after a build that set +// one has finished. TrainAotCacheTask drops those rather than passing them to the training run, and +// there is no way to make one from inside a test: an environment is inherited, not written. +tasks.named('test') { + environment 'GRAILS_TRAINING_LEFTOVER', '' +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index 9a7f0ddbb8d..f2566c1f9cc 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -116,11 +116,12 @@ abstract class TrainAotCacheTask extends DefaultTask { command << "--server.port=${port.get()}".toString() File output = new File(temporaryDir, 'training.log') - Process process = new ProcessBuilder(command) + ProcessBuilder builder = new ProcessBuilder(command) .directory(directory) .redirectErrorStream(true) .redirectOutput(output) - .start() + withoutEmptyVariables(builder.environment()) + Process process = builder.start() try { awaitStarted(process, output) exercise() @@ -136,6 +137,30 @@ abstract class TrainAotCacheTask extends DefaultTask { cache.name, (cache.length() / (1024 * 1024)) as long, paths.get().size()) } + /** + * Drops the variables that are present but empty from what the run will inherit. + * + *

    The run inherits the daemon's environment, and the daemon's is not the one the build was + * started from. A daemon that once ran a build with a variable set keeps the name afterwards + * and empties the value, so a later build started from a shell that never mentioned it hands + * the run {@code SOME_VARIABLE=""} all the same.

    + * + *

    Spring Boot binds an environment variable over the application's own configuration, and + * relaxed binding means {@code GRAILS_MONGODB_URL} is {@code grails.mongodb.url}. So an empty + * leftover replaced a configured value with nothing, and the training run failed on a property + * the application had set correctly -- reporting it against a name nobody had typed, in a + * build that had run cleanly minutes earlier from a different shell.

    + * + *

    An empty variable says nothing that an absent one does not, so it is not passed on. What + * the build was actually given, empty or not, still arrives: this drops only what the daemon + * kept after the build that set it had finished.

    + */ + private static void withoutEmptyVariables(Map environment) { + environment.entrySet().removeIf { Map.Entry variable -> + !variable.value + } + } + /** * Refuses to start a run that could not be ended properly, before it is started. * diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index 08b946802cf..d7afeb4e85c 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -119,6 +119,49 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ task } + void 'a variable the daemon kept but emptied is not handed to the run'() { + given: 'a run that writes down the environment it was given, and ends' + File application = new File(temporaryFolder, 'environment') + application.mkdirs() + new File(application, 'reports.jar').text = 'stands in for the archive' + File seen = new File(temporaryFolder, 'seen-environment.txt') + File script = new File(temporaryFolder, 'reporting-jvm.sh') + script.text = """#!/bin/sh +env > '${seen.absolutePath}' +exit 1 +""" + script.setExecutable(true) + TrainAotCacheTask task = project.tasks.create('trainEnvironment', TrainAotCacheTask) + task.applicationDirectory.set(application) + task.archiveFileName.set('reports.jar') + task.cacheFile.set(new File(application, 'demo.aot')) + task.metadataFile.set(new File(application, 'aot-cache.properties')) + task.javaExecutable.set(script.absolutePath) + task.javaVersion.set('25.0.1+9') + task.javaVendor.set('A Vendor') + task.jvmArguments.set([]) + task.paths.set([]) + task.port.set(18096) + task.startTimeoutSeconds.set(5) + + and: 'which this build gives the test worker, because an environment cannot be written' + assert System.getenv().containsKey('GRAILS_TRAINING_LEFTOVER') + assert !System.getenv('GRAILS_TRAINING_LEFTOVER') + + when: + task.train() + + then: + thrown(GradleException) + + and: 'Spring Boot binds an environment variable over the application configuration, so an ' + + 'empty one left behind by a daemon replaces a configured value with nothing' + !seen.readLines().any { String line -> line.startsWith('GRAILS_TRAINING_LEFTOVER=') } + + and: 'while the environment the build was actually given still arrives' + seen.readLines().any { String line -> line.startsWith('PATH=') } + } + void 'a run that never starts serving fails the build'() { given: 'an archive that is not one, so the run ends immediately' TrainAotCacheTask task = task('not-an-archive.jar', []) From eef515dfaedf5fd2405bc485247fd5b84e72e025 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Mon, 10 Aug 2026 18:00:06 -0500 Subject: [PATCH 069/115] Ask about the return that rewinds a line, not the one that ends it A banner is printed with println, so its line ending is the platform's: \n where it is read on Linux or macOS, \r\n on Windows. The check for nothing being drawn over asked whether any \r had been written at all, which on Windows is true of every line the banner prints, and the Windows job has failed on it in all five attempts. Over-drawing is a return on its own -- one that rewinds to the start of a line so something else can be written over it. Ask about that instead, and the same question holds on every platform. --- .../groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy index 74e201f5fd4..6640184ac9a 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy @@ -129,9 +129,14 @@ class GrailsBannerNativeMarkSpec extends Specification { when: 'a terminal, a redirected log, or an application that has turned colour off' String output = plain(new StartedAs(image: true)) - then: 'one word, once, and nothing drawn over' + then: 'one word, once' output.count('N A T I V E') == 1 - !output.contains('\r') + + and: 'nothing drawn over -- a return only ever ends a line, never rewinds one' + // A banner is printed with println, so the line ending is the platform's: \n where + // this is read on Linux or macOS, \r\n on Windows. What over-drawing looks like is a + // return on its own, so that is what this asks about, on every platform alike. + !output.replace('\r\n', '\n').contains('\r') } void 'an application can say something else'() { From 28765039297f066ac1c7b45f095c5ced1dc83b6f Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Mon, 10 Aug 2026 18:34:19 -0500 Subject: [PATCH 070/115] Fold the task's two javadoc blocks into one Stopping the task being cached added its reasoning as a second javadoc block under the first. Only the last one before a declaration is its javadoc, so the description that was there -- and with it @author and @since -- had been shadowed since. One block now, with the block tags where javadoc expects them. --- .../views/gsp/GroovyPageForkCompileTask.groovy | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy index cc4ecc63329..331e9658c2b 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPageForkCompileTask.groovy @@ -58,21 +58,21 @@ import org.grails.gradle.plugin.views.ViewCompileOptions * This Task is a Forked Java Task that is configurable with fork options provided * by {@link ViewCompileOptions} * - * @author David Estes - * @since 4.0 - */ -/** - * Not cacheable. A page is compiled by a forked Groovy, and what comes out depends on which Groovy - * did it -- which this task's inputs do not describe, because {@code AbstractCompile} does not - * track its own classpath: an application building a native image resolves Groovy 6, and one + *

    Not cacheable. A page is compiled by a forked Groovy, and what comes out depends on which + * Groovy did it -- which this task's inputs do not describe, because {@code AbstractCompile} does + * not track its own classpath: an application building a native image resolves Groovy 6, and one * training a cache resolves Groovy 5. Cached, the first build's pages were handed to the second, * which failed at the moment a page was first rendered, with - * {@code BUG! your call tried to do a property set} -- long after the build said it had succeeded. + * {@code BUG! your call tried to do a property set} -- long after the build said it had + * succeeded.

    * *

    Which Java did the compiling is described, by {@link #getJavaLauncher()}. Which Groovy is * not, and this stays uncacheable until it is.

    * *

    Compiling them again costs seconds. Getting this wrong costs an afternoon.

    + * + * @author David Estes + * @since 4.0 */ @CompileStatic @DisableCachingByDefault(because = 'What a forked compiler produces is not described by this task\'s inputs') From 1240ce7857802540b1ce198977967c43fc3a6829 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 18:15:21 -0700 Subject: [PATCH 071/115] Keep the setters a domain class's constraints are applied through A constraint that names no registered Constraint is applied by setting a property of the same name, and through Groovy rather than by a call the compiler can see: ((GroovyObject) this).setProperty(constraintName, constrainingValue) So `password: true` is a reflective invocation of setPassword(boolean). An image keeps the members something asked for, nothing asked, and an application started and then died the first time anything was validated -- naming a setter nobody had written: MissingReflectionRegistrationError: Cannot reflectively invoke method 'public void grails.gorm.validation.DefaultConstrainedProperty.setPassword(boolean)' Not left to a tracing agent, because validation is lazy: the evaluator is built the first time something is validated, so a run watched against a database that already had its data never evaluated a constraint and recorded nothing. The same image then failed against an empty one. Which database an image happened to be traced against is not a thing anyone would think to hold constant, and it decided whether the image worked. (cherry picked from commit 0b35a2901335cc9e2086028af6c979bdc553c041) --- .../aot/ConstrainedPropertyRuntimeHints.java | 74 +++++++++++++++++++ .../resources/META-INF/spring/aot.factories | 2 + ...ConstrainedPropertyRuntimeHintsSpec.groovy | 69 +++++++++++++++++ 3 files changed, 145 insertions(+) create mode 100644 grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java create mode 100644 grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories create mode 100644 grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy diff --git a/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java b/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java new file mode 100644 index 00000000000..0707e0523d9 --- /dev/null +++ b/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java @@ -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 grails.gorm.validation.aot; + +import org.springframework.aot.hint.MemberCategory; +import org.springframework.aot.hint.RuntimeHints; +import org.springframework.aot.hint.RuntimeHintsRegistrar; +import org.springframework.lang.Nullable; + +/** + * Registers the constrained property a domain class's constraints are applied to. + * + *

    A constraint that names no registered {@code Constraint} is applied by setting a property of + * the same name, through Groovy rather than by a call the compiler can see: + * {@code ((GroovyObject) this).setProperty(constraintName, constrainingValue)}. So + * {@code password: true} is a reflective invocation of {@code setPassword(boolean)}, and an image + * keeps only the members something asks for.

    + * + *

    Without these, an application starts and then fails the first time a domain instance is + * validated, naming a setter nobody wrote:

    + * + * 
    + * MissingReflectionRegistrationError: Cannot reflectively invoke method
+ * 'public void grails.gorm.validation.DefaultConstrainedProperty.setPassword(boolean)'
+ *
    + * + *

    Registered here rather than left to a tracing agent because an agent records only the + * constraints the run it watched happened to evaluate. Validation is lazy -- the evaluator is built + * the first time something is validated -- so an application whose data already exists never + * validates during tracing and records nothing, and the same image then fails against an empty + * database. Which of the two an image was traced against is not a property anyone would think to + * keep constant.

    + * + * @since 8.0 + */ +public class ConstrainedPropertyRuntimeHints implements RuntimeHintsRegistrar { + + /** + * The types a constraint is set on. Named as strings, and registered only when present, so this + * stays correct for an application that does not have every one of them on its classpath. + */ + private static final String[] CONSTRAINED_TYPES = { + "grails.gorm.validation.DefaultConstrainedProperty", + "grails.gorm.validation.ConstrainedProperty", + "org.grails.datastore.gorm.validation.constraints.builder.ConstrainedPropertyBuilder" + }; + + @Override + public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { + for (String type : CONSTRAINED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + } + } + +} diff --git a/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories b/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories new file mode 100644 index 00000000000..245d6f5cffe --- /dev/null +++ b/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories @@ -0,0 +1,2 @@ +org.springframework.aot.hint.RuntimeHintsRegistrar=\ +grails.gorm.validation.aot.ConstrainedPropertyRuntimeHints diff --git a/grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy b/grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..2f2a4b47369 --- /dev/null +++ b/grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy @@ -0,0 +1,69 @@ +/* + * 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 grails.gorm.validation.aot + +import grails.gorm.validation.DefaultConstrainedProperty + +import org.springframework.aot.hint.MemberCategory +import org.springframework.aot.hint.RuntimeHints +import org.springframework.aot.hint.TypeReference + +import spock.lang.Specification + +/** + * Covers a domain class's constraints surviving into an ahead-of-time image. + * + *

    A constraint that names no registered Constraint is applied by setting a property of the same + * name through Groovy, so it is a reflective call the compiler never sees. Without these hints an + * application starts and then fails the first time anything is validated.

    + */ +class ConstrainedPropertyRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void setup() { + new ConstrainedPropertyRuntimeHints().registerHints(hints, getClass().classLoader) + } + + private boolean registered(Class type) { + def hint = hints.reflection().getTypeHint(TypeReference.of(type)) + hint != null && hint.memberCategories.contains(MemberCategory.INVOKE_PUBLIC_METHODS) + } + + void 'the property a constraint is set on is registered'() { + expect: 'password: true is a reflective call to setPassword(boolean), which an image keeps ' + + 'only when something asked for it' + registered(DefaultConstrainedProperty) + } + + void 'a setter a constraint is applied through is one of the methods registered'() { + given: 'the constraint that failed in an image, named the way the failure named it' + def setter = DefaultConstrainedProperty.getMethod('setPassword', boolean) + + expect: 'declared methods are registered, so the setter is reachable rather than stripped' + setter != null + hints.reflection().getTypeHint(TypeReference.of(DefaultConstrainedProperty)) + .memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) + } + + void 'the builder that applies them is registered'() { + expect: + registered(org.grails.datastore.gorm.validation.constraints.builder.ConstrainedPropertyBuilder) + } +} From 49ec1f06a4d03d15cb954c20b82a76244709fa6a Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 22:15:13 -0700 Subject: [PATCH 072/115] Record the reflection a running application does, from a declared list of paths Reading the build output registers an application's own artefacts and needs no run, which is why it is done that way. What it cannot see is the framework reflecting on its own behalf while a request is served -- a controller method reached through Groovy's dispatch, a conversion asked for while binding a form. None of that is in the application's classes, so an image built from the build output alone starts, serves its home page, and fails on the first request that takes such a path, naming a method nobody wrote. traceNativeMetadata runs the application under the agent over a list someone declared, and merges what it recorded into the sources: grails { nativeMetadata { paths = ['/', '/login', '/book', '/book/create'] forms = ['/book/create'] } } Forms are submitted, not merely fetched, and with the fields the form declares rather than the fields someone remembered. Binding a form is a different half of the framework from rendering one and it is the half that converts: a checkbox arrives as a string and lands on a boolean, so a form submitted without one asks the conversion service nothing and the image is built without the answer. That is not hypothetical -- it is how saving a record failed in an image whose trace had posted two strings. A path that answers with a server error fails the task, because a trace of an error page records the error rather than the page. A java without the agent is refused before the application is started, since the agent ships with GraalVM and the JDK running the build usually is not one -- which otherwise appears as a message about a library path. The list is the coverage, and the documentation says so: what nobody wrote down is missing from the image, in the way that only shows up when somebody uses it. (cherry picked from commit 4679a0a674f8f56f5592fff68de58dfd3f25525f) --- .../en/guide/deployment/deploymentAot.adoc | 33 ++ .../plugin/aot/NativeMetadataExtension.groovy | 62 ++++ .../plugin/aot/TraceNativeMetadataTask.groovy | 326 ++++++++++++++++++ .../plugin/core/GrailsGradlePlugin.groovy | 54 +++ .../aot/TraceNativeMetadataTaskSpec.groovy | 176 ++++++++++ .../gradle/plugin/aot/TracedRunFixture.groovy | 76 ++++ 6 files changed, 727 insertions(+) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy diff --git a/grails-doc/src/en/guide/deployment/deploymentAot.adoc b/grails-doc/src/en/guide/deployment/deploymentAot.adoc index 1a902b20a58..3ec318ececc 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAot.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAot.adoc @@ -99,3 +99,36 @@ Reference another bean by name instead, or express the collaborator as a nested Abstract bean definitions — templates that exist only to be inherited through `bean.parent` — are excluded from generation, because Spring has no representation for them in generated code. Definitions that inherit from one are unaffected: they are generated from their merged definition, with the inherited values already folded in. AOT processing on its own does not make an application ready for a native image. A native image additionally requires reachability metadata covering the resources and reflection an application performs at runtime. + +==== Recording reflection for a native image + +Some of that metadata is written for you. The build reads its own output — the compiled artefacts, and the manifest naming each compiled page — and registers them, so a controller, a domain class or a GSP survives into an image without anything having to run. + +What that cannot describe is the framework reflecting on its own behalf while a request is served: a controller method reached through Groovy's dispatch, a conversion asked for while a form is bound. Those are not the application's classes, so nothing in the build output names them. An image built without them starts, serves its home page, and fails on the first request that takes such a path — with `MissingReflectionRegistrationError`, naming a method nobody wrote. + +`traceNativeMetadata` runs the application under GraalVM's tracing agent and records what it actually did: + +[source,groovy] +---- +grails { + nativeMetadata { + paths = ['/', '/login', '/book', '/book/create'] + forms = ['/book/create'] + } +} +---- + +[source,bash] +---- +./gradlew traceNativeMetadata +---- + +The result is merged into `src/native/resources/META-INF/native-image`, alongside the source rather than under `build`, because which paths an image was built to cover is worth reviewing and worth committing. + +`paths` are asked for. `forms` are asked for *and submitted*: the page is read, the fields the form declares are filled in, and they are posted to the action the form names. Submitting matters separately from rendering, because binding a form is a different half of the framework from rendering one — and it is the half that converts. A checkbox arrives as a string and lands on a boolean property, so a form submitted without one never asks the conversion service anything, and the image is built without the answer. + +The task fails if a path answers with a server error, because what a failed request records is the error page rather than the page. + +NOTE: The agent ships with GraalVM rather than with a JDK, and it must trace the archive the image will be built from — which is compiled for GraalVM's Java. The task uses the project toolchain, which for a project that builds an image is already a GraalVM; `grails.nativeMetadata.javaExecutable` points it elsewhere. + +WARNING: The agent records only what ran. A path that is not listed is not covered, and it will be missing in the way that only appears when somebody uses that page. Treat the list as the coverage it is, and extend it as the application grows. diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy new file mode 100644 index 00000000000..9984411e12f --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy @@ -0,0 +1,62 @@ +/* + * 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.grails.gradle.plugin.aot + +import groovy.transform.CompileStatic +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property + +/** + * What {@code traceNativeMetadata} asks the application for. + * + *

    Declared rather than discovered. The agent records what ran, so this list is the coverage: a + * path nobody wrote down is a path missing from the image, and it will be missing in the way that + * only shows up when somebody uses it.

    + * + * @since 8.0 + */ +@CompileStatic +abstract class NativeMetadataExtension { + + /** Paths to ask for. */ + abstract ListProperty getPaths() + + /** + * Pages whose form is to be submitted, which is not the same as asking for the page. Rendering a + * form and binding one are different halves of the framework, and only the second one converts + * anything. + */ + abstract ListProperty getForms() + + abstract ListProperty getJvmArguments() + + abstract Property getPort() + + abstract Property getStartTimeoutSeconds() + + /** + * A java from a GraalVM, which is where the agent lives. Left unset, the project's toolchain is + * used -- which is a GraalVM already for a project that builds an image. + */ + abstract Property getJavaExecutable() + + /** Where what was recorded is merged, in the application's sources so it can be reviewed. */ + abstract DirectoryProperty getOutputDirectory() +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy new file mode 100644 index 00000000000..cfb015e1057 --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -0,0 +1,326 @@ +/* + * 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.grails.gradle.plugin.aot + +import java.time.Duration +import java.util.concurrent.TimeUnit +import java.util.regex.Matcher +import java.util.regex.Pattern + +import groovy.transform.CompileStatic +import org.gradle.api.DefaultTask +import org.gradle.api.GradleException +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.file.RegularFileProperty +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputFile +import org.gradle.api.tasks.Internal +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction +import org.gradle.work.DisableCachingByDefault + +/** + * Runs the application under GraalVM's tracing agent and writes down the reflection it did. + * + *

    {@code GenerateNativeMetadataTask} records an application's own artefacts by reading the build + * output, which needs no run and misses nothing of the application's. What it cannot know is the + * framework's own reflection along a request path -- a controller method reached through Groovy's + * dispatch, a conversion asked for while binding a form -- because none of that is in the + * application's classes. An image built without it starts, serves its home page, and fails on the + * request that first takes such a path.

    + * + *

    The agent records exactly that, and records only what ran. So the paths are declared rather + * than discovered, and what is not listed is not covered:

    + * + * 
    + * grails {
+ *     nativeMetadata {
+ *         paths = ['/', '/login', '/book', '/book/create']
+ *         forms = ['/book/create']
+ *     }
+ * }
+ *
    + * + *

    A form is asked for, read, and submitted with the fields it declares, because posting fewer + * than it declares records less than the application does. A checkbox is a string on the wire and a + * boolean on the domain class, so a form submitted without one never asks the conversion service + * anything -- and an image built from that trace fails the first time someone ticks a box.

    + * + *

    Written to the application's sources rather than to the build directory: what an image was + * built from should be reviewable, and a trace is only as good as the paths someone thought of.

    + * + * @since 8.0 + */ +@CompileStatic +@DisableCachingByDefault(because = 'Records what a run of the application did, which is not an output of its inputs') +abstract class TraceNativeMetadataTask extends DefaultTask { + + /** How the agent is asked for, and the only way its output can be merged with what is there. */ + private static final String AGENT = 'native-image-agent' + + /** The names the agent library goes by, one of which is beside a GraalVM's java. */ + private static final List AGENT_LIBRARIES = [ + 'libnative-image-agent.dylib', 'libnative-image-agent.so', 'native-image-agent.dll' + ] + + private static final Pattern FORM = Pattern.compile(/(?is)]*>.*?<\/form>/) + private static final Pattern ACTION = Pattern.compile(/(?i)\baction\s*=\s*"([^"]*)"/) + private static final Pattern FIELD = Pattern.compile(/(?is)<(?:input|select|textarea)\b[^>]*>/) + private static final Pattern NAME = Pattern.compile(/(?i)\bname\s*=\s*"([^"]+)"/) + private static final Pattern VALUE = Pattern.compile(/(?i)\bvalue\s*=\s*"([^"]*)"/) + private static final Pattern TYPE = Pattern.compile(/(?i)\btype\s*=\s*"([^"]+)"/) + + /** The archive to run, which has to be the one the image will be built from. */ + @InputFile + @PathSensitive(PathSensitivity.RELATIVE) + abstract RegularFileProperty getArchiveFile() + + /** + * A java from a GraalVM. The agent ships with GraalVM rather than with a JDK, and an application + * built for an image is compiled for GraalVM's Java -- so the JDK that runs the build is usually + * neither, and running the trace on it fails at load or refuses the class file. + */ + @Input + abstract Property getJavaExecutable() + + @Input + abstract ListProperty getJvmArguments() + + /** Paths to ask for. */ + @Input + abstract ListProperty getPaths() + + /** Pages whose form is to be filled in and submitted. */ + @Input + abstract ListProperty getForms() + + @Input + abstract Property getPort() + + @Input + abstract Property getStartTimeoutSeconds() + + /** + * Where the agent merges what it recorded. Not declared as an output: it is in the application's + * sources, and a directory Gradle believes it owns is a directory Gradle will delete. + */ + @Internal + abstract DirectoryProperty getOutputDirectory() + + @TaskAction + void trace() { + File java = new File(javaExecutable.get()) + File metadata = outputDirectory.get().asFile + metadata.mkdirs() + refuseWithoutAgent(java) + + List command = [] + command << java.absolutePath + command << "-agentlib:${AGENT}=config-merge-dir=${metadata.absolutePath}".toString() + command.addAll(jvmArguments.get()) + command << '-jar' << archiveFile.get().asFile.absolutePath + command << "--server.port=${port.get()}".toString() + + File output = new File(temporaryDir, 'trace.log') + Process process = new ProcessBuilder(command) + .directory(archiveFile.get().asFile.parentFile) + .redirectErrorStream(true) + .redirectOutput(output) + .start() + + List answered = [] + try { + awaitStarted(process, output) + CookieHandler.default = new CookieManager() + paths.get().each { String path -> answered << ask(path) } + forms.get().each { String path -> answered << submit(path) } + } + finally { + stop(process) + } + + answered.each { String line -> logger.lifecycle(' {}', line) } + List failed = answered.findAll { String line -> line.contains(' -> 5') } + if (failed) { + throw new GradleException('The application answered with an error while being traced, so ' + + "what was recorded is the error rather than the page:\n ${failed.join('\n ')}\n" + + "What it printed is in ${output}") + } + logger.lifecycle('Traced {} paths and {} forms into {}', + paths.get().size(), forms.get().size(), metadata) + } + + /** + * Refuses before starting rather than after. Without the agent the JVM stops at load with a + * message about a library path, which reads as a broken machine rather than as the wrong JDK. + */ + private static void refuseWithoutAgent(File java) { + File home = java.parentFile?.parentFile + boolean present = home != null && AGENT_LIBRARIES.any { String library -> + new File(home, "lib/${library}").isFile() + } + if (!present) { + throw new GradleException("${java} has no ${AGENT}, which ships with GraalVM rather than " + + 'with a JDK. Point the project toolchain at a GraalVM, or set ' + + 'grails.nativeMetadata.javaExecutable at one.') + } + } + + /** Asks for a path, reading the body so that rendering it is part of what was recorded. */ + private String ask(String path) { + HttpURLConnection connection = open(path, 'GET') + int status = read(connection) + "GET ${path} -> ${status}".toString() + } + + /** + * Fills in the form on a page and submits it to wherever the form says. + * + *

    The fields come from the page rather than from a list here, because a list here is a list + * to keep up to date, and the one thing a trace must not do is submit less than the form does.

    + */ + private String submit(String path) { + HttpURLConnection page = open(path, 'GET') + String html = body(page) + Matcher form = FORM.matcher(html ?: '') + if (!form.find()) { + return "FORM ${path} -> no form on the page".toString() + } + String markup = form.group() + Matcher action = ACTION.matcher(markup) + String target = action.find() && action.group(1) ? action.group(1) : path + + Map fields = fieldsOf(markup) + if (!fields) { + return "FORM ${path} -> the form declares no fields".toString() + } + + String encoded = fields.collect { String name, String value -> + "${URLEncoder.encode(name, 'UTF-8')}=${URLEncoder.encode(value, 'UTF-8')}" + }.join('&') + + HttpURLConnection post = open(target, 'POST') + post.doOutput = true + post.setRequestProperty('Content-Type', 'application/x-www-form-urlencoded') + post.outputStream.withCloseable { OutputStream out -> out.write(encoded.bytes) } + int status = read(post) + "POST ${target} -> ${status} (${fields.size()} fields, from ${path})".toString() + } + + /** + * What the form would send. A field that carries a value sends it, which is how the token a + * security filter demands is carried; a checkbox sends what a ticked one sends; anything else + * sends something recognisable, so a row in a database says where it came from. + */ + private static Map fieldsOf(String markup) { + Map fields = [:] + Matcher field = FIELD.matcher(markup) + while (field.find()) { + String tag = field.group() + Matcher name = NAME.matcher(tag) + if (!name.find()) { + continue + } + Matcher value = VALUE.matcher(tag) + Matcher type = TYPE.matcher(tag) + String kind = type.find() ? type.group(1).toLowerCase(Locale.ROOT) : 'text' + if (kind in ['submit', 'button', 'reset', 'image', 'file']) { + continue + } + fields[name.group(1)] = value.find() ? value.group(1) + : kind == 'checkbox' || kind == 'radio' ? 'on' + : kind == 'password' ? 'traced-secret' + : "traced-${System.nanoTime()}".toString() + } + fields + } + + private HttpURLConnection open(String path, String method) { + URI uri = URI.create("http://localhost:${port.get()}${path.startsWith('/') ? path : '/' + path}") + HttpURLConnection connection = (HttpURLConnection) uri.toURL().openConnection() + connection.requestMethod = method + connection.instanceFollowRedirects = false + connection.connectTimeout = 10_000 + connection.readTimeout = 60_000 + connection.setRequestProperty('Accept', 'text/html,*/*') + connection + } + + private static int read(HttpURLConnection connection) { + int status = connection.responseCode + InputStream stream = status >= 400 ? connection.errorStream : connection.inputStream + stream?.withCloseable { InputStream it -> it.bytes } + status + } + + private static String body(HttpURLConnection connection) { + int status = connection.responseCode + InputStream stream = status >= 400 ? connection.errorStream : connection.inputStream + stream?.withCloseable { InputStream it -> new String(it.bytes, 'UTF-8') } + } + + private void awaitStarted(Process process, File output) { + long deadline = System.currentTimeMillis() + Duration.ofSeconds(startTimeoutSeconds.get()).toMillis() + while (System.currentTimeMillis() < deadline) { + if (!process.isAlive()) { + throw new GradleException('The application ended before it started serving. ' + + "What it printed is in ${output}") + } + if (output.isFile() && output.text.contains('Started ')) { + return + } + if (serving()) { + return + } + Thread.sleep(250L) + } + throw new GradleException("The application did not start within ${startTimeoutSeconds.get()}s. " + + "What it printed is in ${output}") + } + + private boolean serving() { + try { + new Socket().withCloseable { Socket socket -> + socket.connect(new InetSocketAddress('localhost', port.get()), 500) + true + } + } + catch (IOException ignored) { + false + } + } + + /** + * Asks the run to stop and waits for it. The agent writes what it recorded as the JVM exits, so + * a run that is killed leaves the metadata as it found it. + */ + private static void stop(Process process) { + if (!process.isAlive()) { + return + } + process.destroy() + if (!process.waitFor(120, TimeUnit.SECONDS)) { + process.destroyForcibly() + throw new GradleException('The application did not stop, so the agent wrote nothing') + } + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 9e9b3ff2c24..14efe02a34c 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -71,6 +71,8 @@ import org.grails.gradle.plugin.exploded.ExplodedCompatibilityRule import org.grails.gradle.plugin.exploded.ExplodedDisambiguationRule import org.grails.gradle.plugin.exploded.GrailsExplodedPlugin import org.grails.gradle.plugin.aot.AotCacheExtension +import org.grails.gradle.plugin.aot.TraceNativeMetadataTask +import org.grails.gradle.plugin.aot.NativeMetadataExtension import org.grails.gradle.plugin.aot.GenerateNativeMetadataTask import org.grails.gradle.plugin.aot.TrainAotCacheTask import org.grails.gradle.plugin.model.GrailsClasspathToolingModelBuilder @@ -102,6 +104,9 @@ class GrailsGradlePlugin implements Plugin { private static final int TRAINING_PORT = 18080 + /** Not the training port: a trace and a training run are both a started application. */ + private static final int TRACING_PORT = 18081 + private static final int TRAINING_START_TIMEOUT_SECONDS = 180 private static final String CLI_PID_FILE_PROPERTY = 'grails.cli.pid.file' @@ -983,6 +988,55 @@ ${importStatements} GrailsExtension grailsExt = project.extensions.getByType(GrailsExtension) grailsExt.indy.convention(true) } + configureNativeMetadataTrace(project) + } + + /** + * Records the reflection a running application does, which is the half of an image's metadata + * that reading the build output cannot supply. + * + *

    {@code generateNativeMetadata} writes down the application's own artefacts without running + * anything. What it cannot see is the framework reflecting along a request path -- a controller + * method reached through Groovy's dispatch, a conversion asked for while binding a form -- and an + * image built without those starts, serves its home page, and fails on the first request that + * needs one.

    + * + *

    Run deliberately rather than as part of a build: it starts the application, and what it + * writes belongs in the sources beside the code, where the next person can see which paths an + * image was built to cover.

    + */ + protected void configureNativeMetadataTrace(Project project) { + NativeMetadataExtension extension = ((ExtensionAware) project.extensions.getByName('grails')) + .extensions.create('nativeMetadata', NativeMetadataExtension) + extension.paths.convention(['/']) + extension.forms.convention([]) + extension.jvmArguments.convention(['-Dgrails.env=production']) + extension.port.convention(TRACING_PORT) + extension.startTimeoutSeconds.convention(TRAINING_START_TIMEOUT_SECONDS) + extension.outputDirectory.convention(project.layout.projectDirectory + .dir('src/native/resources/META-INF/native-image')) + + project.pluginManager.withPlugin(SPRING_BOOT_PLUGIN) { + TaskProvider bootJar = project.tasks.named('bootJar') + Provider launcher = trainingLauncher(project) + + project.tasks.register('traceNativeMetadata', TraceNativeMetadataTask) { TraceNativeMetadataTask task -> + task.group = BasePlugin.BUILD_GROUP + task.description = 'Runs the application under the tracing agent and records the reflection it does' + task.dependsOn(bootJar) + task.archiveFile.set(project.provider { project.layout.projectDirectory.file(archiveOf(bootJar).absolutePath) }) + // The project's toolchain unless told otherwise, which for a project that builds an + // image is the GraalVM the image is built with -- and the agent is only there. + task.javaExecutable.set(extension.javaExecutable + .orElse(launcher.map { JavaLauncher java -> java.executablePath.asFile.absolutePath })) + task.jvmArguments.set(extension.jvmArguments) + task.paths.set(extension.paths) + task.forms.set(extension.forms) + task.port.set(extension.port) + task.startTimeoutSeconds.set(extension.startTimeoutSeconds) + task.outputDirectory.set(extension.outputDirectory) + } + } } protected void configureBootRunPidFile(Project project) { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy new file mode 100644 index 00000000000..4a6180ce8e5 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy @@ -0,0 +1,176 @@ +/* + * 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.grails.gradle.plugin.aot + +import org.gradle.api.GradleException +import org.gradle.api.Project +import org.gradle.testfixtures.ProjectBuilder +import spock.lang.Specification +import spock.lang.TempDir + +/** + * Covers the run that records what an image will need. + * + *

    The agent itself is GraalVM's and is not exercised here: what is worth covering is what the + * task asks the application for, because the metadata is only ever as complete as that.

    + */ +class TraceNativeMetadataTaskSpec extends Specification { + + @TempDir + File temporaryFolder + + Project project = ProjectBuilder.builder().build() + + private File requestedFile + private File metadata + + List getRequested() { + requestedFile?.isFile() ? requestedFile.readLines().findAll { it } : [] + } + + /** + * A task whose run really serves. + * + *

    Launched through a script standing in for GraalVM's java: the agent is asked for on the + * command line, and a JDK without one stops at load -- which is the thing the task refuses in + * advance, and is covered separately below.

    + */ + private TraceNativeMetadataTask task(List paths, List forms, String behaviour = 'ok') { + File application = new File(temporaryFolder, 'application') + application.mkdirs() + File archive = new File(application, 'traced.jar') + archive.text = 'stands in for the archive' + requestedFile = new File(temporaryFolder, 'requested.txt') + requestedFile.text = '' + metadata = new File(temporaryFolder, 'metadata') + + // A java with the agent beside it, which is what the task looks for before it starts. + File home = new File(temporaryFolder, 'graalvm') + new File(home, 'bin').mkdirs() + new File(home, 'lib').mkdirs() + new File(home, 'lib/libnative-image-agent.dylib').text = 'stands in for the agent' + File script = new File(home, 'bin/java') + script.text = """#!/bin/sh +port="" +for arg in "\$@"; do + case "\$arg" in + --server.port=*) port="\${arg#--server.port=}" ;; + esac +done +exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ + -cp '${System.getProperty('java.class.path')}' \\ + ${TracedRunFixture.name} "\$port" '${requestedFile.absolutePath}' ${behaviour} +""" + script.setExecutable(true) + + TraceNativeMetadataTask task = project.tasks.create("trace${paths.size()}${forms.size()}${behaviour}".replaceAll('-', ''), TraceNativeMetadataTask) + task.archiveFile.set(archive) + task.javaExecutable.set(script.absolutePath) + task.jvmArguments.set([]) + task.paths.set(paths) + task.forms.set(forms) + task.port.set(18077) + task.startTimeoutSeconds.set(60) + task.outputDirectory.set(metadata) + task + } + + void 'every path named is asked for'() { + given: + TraceNativeMetadataTask task = task(['/', '/login'], []) + + when: + task.trace() + + then: 'the agent records what ran, so what is not asked for is not in the image' + requested.contains('GET /') + requested.contains('GET /login') + } + + void 'a form is submitted with the fields it declares'() { + given: + TraceNativeMetadataTask task = task([], ['/create']) + + when: + task.trace() + + then: 'to the action the form names, rather than to the page it was read from' + String posted = requested.find { it.startsWith('POST /save') } + posted != null + + and: 'carrying the value a field already had, which is how a security token is carried' + posted.contains('_csrf=a-token') + + and: 'and what a ticked checkbox sends -- the field whose absence means nothing is converted' + posted.contains('published=on') + + and: 'every other field the form declares' + posted.contains('title=') + posted.contains('secret=') + + and: 'but not the button that submits it' + !posted.contains('go=') + } + + void 'a path that answers with an error fails the trace'() { + given: 'because what would be recorded is the error page rather than the page' + TraceNativeMetadataTask task = task(['/broken'], []) + + when: + task.trace() + + then: + GradleException e = thrown() + e.message.contains('answered with an error') + e.message.contains('/broken') + } + + void 'a form that fails to submit fails the trace'() { + given: + TraceNativeMetadataTask task = task([], ['/create'], 'save-fails') + + when: + task.trace() + + then: 'a save that 500s during tracing records the failure and nothing of the save' + GradleException e = thrown() + e.message.contains('answered with an error') + } + + void 'a java without the agent is refused before the application is started'() { + given: 'the agent ships with GraalVM, so the JDK running the build is usually not one' + File plain = new File(temporaryFolder, 'plain-jdk/bin/java') + plain.parentFile.mkdirs() + plain.text = '#!/bin/sh\nexit 0\n' + plain.setExecutable(true) + TraceNativeMetadataTask task = task(['/'], []) + task.javaExecutable.set(plain.absolutePath) + + when: + task.trace() + + then: 'named, rather than left as a message about a library path from a JVM that would not load' + GradleException e = thrown() + e.message.contains('native-image-agent') + e.message.contains('GraalVM') + + and: 'and nothing was run' + requested.isEmpty() + } +} diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy new file mode 100644 index 00000000000..96892fcb2f1 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy @@ -0,0 +1,76 @@ +/* + * 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.grails.gradle.plugin.aot + +import java.util.concurrent.CountDownLatch + +import com.sun.net.httpserver.HttpExchange +import com.sun.net.httpserver.HttpServer + +/** + * An application for the trace to record: it serves a form, and writes down what it was asked for. + * + *

    The form is the point. A page can be fetched by anything; only submitting one shows whether the + * fields a form declares are the fields that arrive.

    + */ +class TracedRunFixture { + + static void main(String[] args) { + int port = Integer.parseInt(args[0]) + File requested = new File(args[1]) + String behaviour = args.length > 2 ? args[2] : 'ok' + + HttpServer server = HttpServer.create(new InetSocketAddress('localhost', port), 0) + server.createContext('/') { HttpExchange exchange -> + String path = exchange.requestURI.path + String method = exchange.requestMethod + String body = method == 'POST' ? exchange.requestBody.getText('UTF-8') : '' + requested << "${method} ${path}${body ? ' ' + body : ''}\n" + + int status = 200 + String response = 'served' + if (path == '/broken') { + status = 500 + response = 'no' + } + else if (path == '/create') { + response = ''' +
    + + + + + +
    ''' + } + else if (path == '/save' && behaviour == 'save-fails') { + status = 500 + response = 'no' + } + + byte[] bytes = response.bytes + exchange.sendResponseHeaders(status, bytes.length) + exchange.responseBody.withCloseable { it.write(bytes) } + } + server.start() + println 'Started Application in 0.05 seconds' + System.out.flush() + new CountDownLatch(1).await() + } +} From 2649ca482b4e0201e7c35f749c351e8027cde36b Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sat, 8 Aug 2026 23:46:15 -0700 Subject: [PATCH 073/115] Let a traced form be told what to put in it Most forms are worth submitting with anything, and a generated value is better than one to keep up to date. A form that authenticates is not: it is only worth submitting with credentials that work, because what a login does on success is the half worth recording, and a rejected one redirects without doing any of it. forms = ['/login?username=admin&password=traced-admin'] A value is used only where the form declares a field of that name; one that matches nothing is reported rather than posted, since a value meant for a field that has since been renamed would otherwise look like coverage of something no longer there. Found by a login that failed in a native image on a constructor that is reached only when a login succeeds -- which no trace had ever managed, the password being new on every start. (cherry picked from commit 6a3f8024e1b41fe642d838328044382d23f75b06) --- .../plugin/aot/TraceNativeMetadataTask.groovy | 30 ++++++++++++++++++- .../aot/TraceNativeMetadataTaskSpec.groovy | 28 +++++++++++++++++ 2 files changed, 57 insertions(+), 1 deletion(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index cfb015e1057..8b044cdc537 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -198,7 +198,25 @@ abstract class TraceNativeMetadataTask extends DefaultTask { *

    The fields come from the page rather than from a list here, because a list here is a list * to keep up to date, and the one thing a trace must not do is submit less than the form does.

    */ - private String submit(String path) { + private String submit(String declared) { + // A form may say what to put in it: /login?username=admin&password=... Most do not need to, + // and a generated value is better than one to keep up to date -- but a form that authenticates + // is only worth submitting with credentials that work, and what it does on success is the + // half worth recording. + int query = declared.indexOf('?') + String path = query < 0 ? declared : declared.substring(0, query) + Map given = [:] + if (query >= 0) { + for (String pair : declared.substring(query + 1).split('&')) { + if (!pair) { + continue + } + int equals = pair.indexOf('=') + String name = URLDecoder.decode(equals < 0 ? pair : pair.substring(0, equals), 'UTF-8') + given[name] = equals < 0 ? '' : URLDecoder.decode(pair.substring(equals + 1), 'UTF-8') + } + } + HttpURLConnection page = open(path, 'GET') String html = body(page) Matcher form = FORM.matcher(html ?: '') @@ -213,6 +231,16 @@ abstract class TraceNativeMetadataTask extends DefaultTask { if (!fields) { return "FORM ${path} -> the form declares no fields".toString() } + // What was asked for wins, but only for a field the form has: a value for a field that is + // not there was meant for a form that has changed, and silently posting it says nothing. + given.each { String name, String value -> + if (fields.containsKey(name)) { + fields[name] = value + } + else { + logger.warn('{} has no field named {}, so that value was not sent', path, name) + } + } String encoded = fields.collect { String name, String value -> "${URLEncoder.encode(name, 'UTF-8')}=${URLEncoder.encode(value, 'UTF-8')}" diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy index 4a6180ce8e5..8a19fa08848 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy @@ -128,6 +128,34 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ !posted.contains('go=') } + void 'a form can be told what to put in it'() { + given: 'a form that authenticates is only worth submitting with credentials that work' + TraceNativeMetadataTask task = task([], ['/create?title=a-known-title']) + + when: + task.trace() + + then: + String posted = requested.find { it.startsWith('POST /save') } + posted.contains('title=a-known-title') + + and: 'while the rest of the form is still filled in' + posted.contains('_csrf=a-token') + posted.contains('published=on') + } + + void 'a value for a field the form does not have is not sent'() { + given: + TraceNativeMetadataTask task = task([], ['/create?nosuchfield=x']) + + when: + task.trace() + + then: 'rather than posting something the application will ignore and calling it covered' + String posted = requested.find { it.startsWith('POST /save') } + !posted.contains('nosuchfield') + } + void 'a path that answers with an error fails the trace'() { given: 'because what would be recorded is the error page rather than the page' TraceNativeMetadataTask task = task(['/broken'], []) From 33af958b12e5e97badd87e1a642145a5905e2d75 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Mon, 10 Aug 2026 18:59:23 -0500 Subject: [PATCH 074/115] Sort the AOT imports the cherry-pick left out of order --- .../org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 14efe02a34c..59d76e038e3 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -71,9 +71,9 @@ import org.grails.gradle.plugin.exploded.ExplodedCompatibilityRule import org.grails.gradle.plugin.exploded.ExplodedDisambiguationRule import org.grails.gradle.plugin.exploded.GrailsExplodedPlugin import org.grails.gradle.plugin.aot.AotCacheExtension -import org.grails.gradle.plugin.aot.TraceNativeMetadataTask -import org.grails.gradle.plugin.aot.NativeMetadataExtension import org.grails.gradle.plugin.aot.GenerateNativeMetadataTask +import org.grails.gradle.plugin.aot.NativeMetadataExtension +import org.grails.gradle.plugin.aot.TraceNativeMetadataTask import org.grails.gradle.plugin.aot.TrainAotCacheTask import org.grails.gradle.plugin.model.GrailsClasspathToolingModelBuilder import org.grails.gradle.plugin.run.FindMainClassTask From 4b9352d4530d91c026613588d9533ab56efdb382 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:49:30 -0600 Subject: [PATCH 075/115] Ask for nullability with the annotation Spring did not deprecate org.springframework.lang.Nullable is deprecated since Spring Framework 7.0, which is what this baseline builds against. The framework already says nullability with JSpecify everywhere else, including in grails-core; the only files still on the Spring annotation are copies of Spring's own. It moves import group as well as name: JSpecify is not Spring, so it belongs with the other third-party imports rather than in the Spring block, which is where checkstyle's import order expects to find it. --- .../src/main/groovy/org/grails/aot/RegistrableTypes.java | 3 ++- .../plugins/web/controllers/aot/ControllerRuntimeHints.java | 3 ++- .../ArtefactClassesBeanFactoryInitializationAotProcessor.java | 3 ++- .../beans/aot/AutowireModeBeanRegistrationAotProcessor.java | 3 ++- .../org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java | 3 ++- .../org/grails/spring/beans/aot/GrailsApiRuntimeHints.java | 3 ++- .../org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java | 3 ++- .../org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java | 2 +- .../spring/beans/aot/GroovyExtensionModuleRuntimeHints.java | 2 +- .../spring/beans/aot/VarargsBeanRegistrationAotProcessor.java | 3 ++- .../groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java | 2 +- .../gorm/validation/aot/ConstrainedPropertyRuntimeHints.java | 3 ++- .../groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java | 3 ++- .../org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java | 2 +- .../groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java | 3 ++- .../grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java | 3 ++- .../grails/web/databinding/aot/DataBindingRuntimeHints.java | 3 ++- .../org/grails/web/mapping/aot/UrlMappingRuntimeHints.java | 3 ++- 18 files changed, 32 insertions(+), 18 deletions(-) diff --git a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java b/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java index 1516677c5e6..840b2b7c54b 100644 --- a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java +++ b/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java @@ -23,6 +23,8 @@ import java.util.LinkedHashSet; import java.util.Set; +import org.jspecify.annotations.Nullable; + import org.springframework.asm.ClassReader; import org.springframework.asm.ClassVisitor; import org.springframework.asm.ConstantDynamic; @@ -32,7 +34,6 @@ import org.springframework.asm.MethodVisitor; import org.springframework.asm.SpringAsmInfo; import org.springframework.asm.Type; -import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; /** diff --git a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java b/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java index 8263cb525d5..6ff7b7fceab 100644 --- a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java +++ b/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java @@ -18,10 +18,11 @@ */ package org.grails.plugins.web.controllers.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; /** * Registers the controller API a request is dispatched through. diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java index 00c661f2fb8..1415d88e56b 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java @@ -26,13 +26,14 @@ import javax.lang.model.element.Modifier; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.generate.GeneratedMethod; import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution; import org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor; import org.springframework.beans.factory.aot.BeanFactoryInitializationCode; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.javapoet.CodeBlock; -import org.springframework.lang.Nullable; import grails.core.GrailsApplication; import grails.plugins.GrailsPlugin; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java index a530e5e9f93..82a52b4b084 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java @@ -20,6 +20,8 @@ import java.util.function.Predicate; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.generate.GenerationContext; import org.springframework.beans.factory.aot.BeanRegistrationAotContribution; import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor; @@ -30,7 +32,6 @@ import org.springframework.beans.factory.support.RegisteredBean; import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.javapoet.CodeBlock; -import org.springframework.lang.Nullable; /** * Carries a bean's autowire mode into the code generated for it ahead of time. diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java index 48ce66481b9..361358200f2 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java @@ -18,6 +18,8 @@ */ package org.grails.spring.beans.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; @@ -26,7 +28,6 @@ import org.springframework.beans.factory.ListableBeanFactory; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.support.BeanDefinitionRegistry; -import org.springframework.lang.Nullable; /** * Registers the registry a plugin declares its beans against. diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java index 75358b26a91..67b5e522947 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java @@ -18,6 +18,8 @@ */ package org.grails.spring.beans.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; @@ -27,7 +29,6 @@ import org.springframework.core.env.Environment; import org.springframework.core.env.PropertyResolver; import org.springframework.core.io.ResourceLoader; -import org.springframework.lang.Nullable; import grails.config.Config; import grails.config.ConfigMap; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java index 013c0520e29..c0167de49e4 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java @@ -18,11 +18,12 @@ */ package org.grails.spring.beans.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; import org.springframework.aot.hint.TypeReference; -import org.springframework.lang.Nullable; import grails.boot.GrailsBanner; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java index b47e925d585..4928450914d 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java @@ -22,6 +22,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.jspecify.annotations.Nullable; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; @@ -31,7 +32,6 @@ import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReaderFactory; -import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; import org.grails.aot.RegistrableTypes; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java index e223b90d6df..c5c07fc72b5 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java @@ -26,6 +26,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.jspecify.annotations.Nullable; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; @@ -33,7 +34,6 @@ import org.springframework.core.io.Resource; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternResolver; -import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; import org.springframework.util.StringUtils; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java index 35ff32e3813..6f5add205ac 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java @@ -24,6 +24,8 @@ import java.util.List; import java.util.function.Predicate; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.generate.GenerationContext; import org.springframework.beans.factory.aot.BeanRegistrationAotContribution; import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor; @@ -35,7 +37,6 @@ import org.springframework.beans.factory.support.RegisteredBean; import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.javapoet.CodeBlock; -import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; /** diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java index 911adaaa1f2..2ebfee041e4 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java @@ -22,6 +22,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.jspecify.annotations.Nullable; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; @@ -31,7 +32,6 @@ import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReaderFactory; -import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; import org.grails.aot.RegistrableTypes; diff --git a/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java b/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java index 0707e0523d9..55df42ba26b 100644 --- a/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java +++ b/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java @@ -18,10 +18,11 @@ */ package grails.gorm.validation.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; /** * Registers the constrained property a domain class's constraints are applied to. diff --git a/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java b/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java index 2e10774ca24..111bdfc450d 100644 --- a/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java +++ b/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java @@ -18,9 +18,10 @@ */ package org.grails.gsp.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; import org.grails.gsp.GroovyPageMetaInfo; diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java index a9c890cf051..1429d9a1087 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java @@ -22,6 +22,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.jspecify.annotations.Nullable; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; @@ -31,7 +32,6 @@ import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReaderFactory; -import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; import org.grails.aot.RegistrableTypes; diff --git a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java b/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java index f519809a210..80b40ef22c2 100644 --- a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java +++ b/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java @@ -18,10 +18,11 @@ */ package org.grails.web.mime.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; /** * Registers the content negotiation API. diff --git a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java b/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java index 7a063c4e760..a8b018804cb 100644 --- a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java +++ b/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java @@ -18,10 +18,11 @@ */ package grails.plugin.scaffolding.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; /** * Registers the controller a scaffolded resource is served by. diff --git a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java b/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java index 35ba34149e9..49e004e19cf 100644 --- a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java +++ b/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java @@ -18,10 +18,11 @@ */ package org.grails.web.databinding.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; /** * Registers the data binding API a request is bound through. diff --git a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java b/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java index fa36d4bf680..14fd803f69a 100644 --- a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java +++ b/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java @@ -18,10 +18,11 @@ */ package org.grails.web.mapping.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; /** * Registers the URL mapping API a request is dispatched through. From 49a59448d68f0c680787ecf075dd5a119ac39a8c Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:49:38 -0600 Subject: [PATCH 076/115] Give two version lookups back the documentation left above a third Three javadoc blocks had come to sit one after another above findContainerVersion. Only the last of them documents it: the first describes reading a version from a jar's manifest and the second from a resource it ships, which are findVersion and findVersionInResource, and both of those were left with none. Moved onto the methods they were written for, and findVersion keeps the param and return it had before the resource lookup was added beside it. --- .../groovy/grails/boot/GrailsBanner.groovy | 125 +++++++++++++----- 1 file changed, 90 insertions(+), 35 deletions(-) diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index f1a9be076b4..fe126b45870 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -22,8 +22,7 @@ import java.lang.management.ManagementFactory import groovy.transform.CompileStatic import groovy.transform.MapConstructor -import groovy.transform.stc.ClosureParams -import groovy.transform.stc.SimpleType +import groovy.util.logging.Slf4j import org.springframework.boot.Banner import org.springframework.boot.ansi.Ansi8BitColor @@ -44,6 +43,7 @@ import grails.util.BuildSettings * * @since 7.1 */ +@Slf4j @CompileStatic @MapConstructor(noArg = true) class GrailsBanner implements Banner { @@ -72,6 +72,16 @@ class GrailsBanner implements Banner { private static final String NO_COLOR = 'none' + private static final String ORDER_PROPERTY = 'grails.banner.versions.order' + + private static final String EXCLUDE_PROPERTY = 'grails.banner.versions.exclude' + + private static final String INCLUDE_PROPERTY = 'grails.banner.versions.include' + + /** Everywhere an application names a version option, and so everywhere one can be misspelt. */ + private static final List VERSION_PROPERTIES = + [ORDER_PROPERTY, EXCLUDE_PROPERTY, INCLUDE_PROPERTY].asImmutable() + String bannerFile = DEFAULT_BANNER_FILE int bannerPaddingTop = 1 int bannerPaddingBottom = 1 @@ -99,11 +109,50 @@ class GrailsBanner implements Banner { artPaddingBottom.times { out.println() } } printMark(environment, out, bannerWidth) - if (shouldDisplayVersions(environment)) { + boolean displayVersions = shouldDisplayVersions(environment) + if (displayVersions) { createVersionsFormatter().format(createBannerVersions(environment), bannerWidth) .forEach { out.println(it) } } bannerPaddingBottom.times { out.println() } + if (displayVersions) { + warnAboutUnrecognisedVersions(environment) + } + } + + /** + * Says which of the version options an application configured were not recognised. + * + *

    An option that names nothing is dropped, and was dropped without a word -- so a name with + * a typo in it reads as a banner that quietly ignores what it was told, and the only way to + * find out is to notice a line that is not there.

    + * + *

    Said after the banner rather than while one is being built. A line logged partway through + * arrives between the mark and the versions, which is the very thing reading a version without + * initialising the library it belongs to was for.

    + */ + protected void warnAboutUnrecognisedVersions(Environment env) { + List unrecognised = unrecognisedVersionOptions(env) + if (unrecognised) { + log.warn('Ignoring unknown banner version option(s) {}; the known options are {}', + unrecognised, VersionOption.values()*.key) + } + } + + /** + * The configured version options that name none of {@link VersionOption}, in the order they + * were written. + * + *

    Which list an option belongs to is not asked. An option is named by an application to say + * that it wants it or does not, and moving one between the shown-by-default set and the + * asked-for set is a decision of this class -- so an application that asked for a version that + * has since become one of the defaults said something recognisable, and is told nothing.

    + */ + protected List unrecognisedVersionOptions(Environment env) { + List known = VersionOption.values()*.key + VERSION_PROPERTIES.collectMany { String property -> + readVersionOptions(env, property).findAll { String option -> !(option in known) } + }.unique() } /** @@ -271,9 +320,9 @@ class GrailsBanner implements Banner { */ protected Map createBannerVersions(Environment env) { def defaultIncluded = (DefaultVersionOption.values()).collect { it.key } - def sortOrder = findConfiguredVersions(env, 'grails.banner.versions.order') { it in VersionOption.values()*.key } - def configExcluded = findConfiguredVersions(env, 'grails.banner.versions.exclude') { it in DefaultVersionOption.values()*.key } - def configIncluded = findConfiguredVersions(env, 'grails.banner.versions.include') { it in OptionalVersionOption.values()*.key } + def sortOrder = findConfiguredVersions(env, ORDER_PROPERTY) + def configExcluded = findConfiguredVersions(env, EXCLUDE_PROPERTY) + def configIncluded = findConfiguredVersions(env, INCLUDE_PROPERTY) def includedVersions = defaultIncluded .tap { removeAll(configExcluded) } .tap { addAll(configIncluded) } @@ -338,24 +387,6 @@ class GrailsBanner implements Banner { versions.findAll { String label, String version -> version != null } } - /** - * The version a library records in the manifest of the jar it ships in. - * - *

    Loaded without being initialised. A version is read about a library rather than - * from it, and running a static initialiser to find one lets the library do whatever it - * does on the way -- Spring Security logs a line of its own from there, which arrived in the - * middle of the banner, between the mark and the very versions it was being read for. The - * manifest is attached to the package when the class is loaded, and loading is all this - * needs.

    - */ - /** - * A version a library records in a resource it ships, read without loading any of its classes. - * - *

    The manifest route only works while a jar is a plain entry on the classpath. Repackaged - * into an executable jar its attributes are no longer attached to the package, and an image has - * no jars at all -- which is why a container version read that way reads as nothing in exactly - * the two places it is most worth having. A resource is still a resource in both.

    - */ /** * The servlet container the application is running on, and the version it records. * @@ -403,6 +434,18 @@ class GrailsBanner implements Banner { findVersion('io.undertow.Undertow') } + /** + * A version a library records in a resource it ships, read without loading any of its classes. + * + *

    The manifest route only works while a jar is a plain entry on the classpath. Repackaged + * into an executable jar its attributes are no longer attached to the package, and an image has + * no jars at all -- which is why a container version read that way reads as nothing in exactly + * the two places it is most worth having. A resource is still a resource in both.

    + * + * @param resource the classpath location of the resource to read + * @param key the property within it that carries the version + * @return the version, or {@code null} where the resource or the property is absent + */ protected static String findVersionInResource(String resource, String key) { InputStream stream = GrailsBanner.classLoader.getResourceAsStream(resource) if (stream == null) { @@ -418,6 +461,19 @@ class GrailsBanner implements Banner { } } + /** + * The version a library records in the manifest of the jar it ships in. + * + *

    Loaded without being initialised. A version is read about a library rather than + * from it, and running a static initialiser to find one lets the library do whatever it + * does on the way -- Spring Security logs a line of its own from there, which arrived in the + * middle of the banner, between the mark and the very versions it was being read for. The + * manifest is attached to the package when the class is loaded, and loading is all this + * needs.

    + * + * @param className the fully qualified name of a class the library ships + * @return the version, or {@code null} where the class is absent or records none + */ protected static String findVersion(String className) { try { Package pkg = Class.forName(className, false, GrailsBanner.classLoader).package @@ -428,21 +484,20 @@ class GrailsBanner implements Banner { } /** - * Finds the configured versions from the environment. + * The version options configured under the given property that name something. * * @param env the current environment * @param propertyName the property name to look for - * @param filter the filter closure - * @return a list of configured versions + * @return the options that name a {@link VersionOption}, in the order they were written */ - private static List findConfiguredVersions( - Environment env, - String propertyName, - @ClosureParams( - value = SimpleType, - options = ['java.lang.String'] - ) Closure filter) { - env.getProperty(propertyName, List, [] as List).findAll(filter) + private static List findConfiguredVersions(Environment env, String propertyName) { + List known = VersionOption.values()*.key + readVersionOptions(env, propertyName).findAll { String option -> option in known } + } + + /** What an application wrote under the given property, or nothing where it wrote none. */ + private static List readVersionOptions(Environment env, String propertyName) { + env.getProperty(propertyName, List, [] as List) } /** From cbc1ffa1720a7865acb9805446c4b2dc4aa1acbf Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:49:49 -0600 Subject: [PATCH 077/115] Let every datastore name its event publisher rather than hold one Hibernate 7 and MongoDB had been changed to register the publisher as a definition and refer to it by name; Hibernate 5 and Neo4j still built one and put the object itself in the definition, which is the shape that cannot be generated ahead of time -- a definition is a recipe, and there is no way to write down a publisher bound to a running context. The choice the two that were converted make is the choice findEventPublisher already makes, so it is asked once, beside it, and the copies each of them carried are gone. The locals they had both stopped reading go with them. Neo4j asks the question inline instead. That build resolves grails-datamapping-core from a release rather than from the source beside it, so a method added here is not one it can call. --- ...HibernateDatastoreSpringInitializer.groovy | 9 +++-- ...HibernateDatastoreSpringInitializer.groovy | 13 +------ .../MongoDbDataStoreSpringInitializer.groovy | 11 +----- .../Neo4jDataStoreSpringInitializer.groovy | 20 ++++++----- .../AbstractDatastoreInitializer.groovy | 20 +++++++++++ ...tastoreInitializerConfigurationSpec.groovy | 36 +++++++++++++++++++ 6 files changed, 76 insertions(+), 33 deletions(-) diff --git a/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy b/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy index 7d4b037d3d8..ec8f5953d6d 100644 --- a/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy +++ b/grails-data-hibernate5/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy @@ -20,7 +20,6 @@ import groovy.transform.CompileStatic import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.context.ApplicationContext -import org.springframework.context.ApplicationEventPublisher import org.springframework.context.support.GenericApplicationContext import org.springframework.core.env.ConfigurableEnvironment import org.springframework.core.env.PropertyResolver @@ -135,7 +134,6 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { } Closure getBeanDefinitions(BeanDefinitionRegistry beanDefinitionRegistry) { - ApplicationEventPublisher eventPublisher = super.findEventPublisher(beanDefinitionRegistry) Closure beanDefinitions = { def common = getCommonConfiguration(beanDefinitionRegistry, 'hibernate') common.delegate = delegate @@ -147,12 +145,17 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { def config = this.configuration Object configurationReference = configurationReference(beanDefinitionRegistry) final boolean isGrailsPresent = isGrailsPresent() + // Registered rather than built here, so what the datastore holds is a reference the + // container can build. Holding the publisher itself puts a live object in the + // definition, and generating code for a definition means writing out what it holds -- + // which a publisher bound to a running context is not. + grailsDatastoreEventPublisher(findEventPublisherClass(beanDefinitionRegistry)) dataSourceConnectionSourceFactory(CachedDataSourceConnectionSourceFactory) hibernateConnectionSourceFactory(HibernateConnectionSourceFactory, persistentClasses as Class[]) { bean -> bean.autowire = true dataSourceConnectionSourceFactory = ref('dataSourceConnectionSourceFactory') } - hibernateDatastore(HibernateDatastore, configurationReference, hibernateConnectionSourceFactory, eventPublisher) { bean -> + hibernateDatastore(HibernateDatastore, configurationReference, hibernateConnectionSourceFactory, ref('grailsDatastoreEventPublisher')) { bean -> bean.primary = true } sessionFactory(hibernateDatastore: 'getSessionFactory') { bean -> diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy b/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy index 2be5b60d9d3..62763ef2202 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/grails/orm/bootstrap/HibernateDatastoreSpringInitializer.groovy @@ -21,15 +21,11 @@ import groovy.transform.CompileStatic import org.springframework.beans.factory.support.BeanDefinitionRegistry import grails.spring.BeanBuilder import org.springframework.context.ApplicationContext -import org.springframework.context.ApplicationEventPublisher -import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.support.GenericApplicationContext import org.springframework.core.env.ConfigurableEnvironment import org.springframework.core.env.PropertyResolver import org.springframework.transaction.PlatformTransactionManager -import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher -import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher import org.grails.datastore.gorm.bootstrap.AbstractDatastoreInitializer import org.grails.datastore.gorm.jdbc.connections.CachedDataSourceConnectionSourceFactory import org.grails.datastore.gorm.support.AbstractDatastorePersistenceContextInterceptor @@ -156,7 +152,6 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { } Closure getBeanDefinitions(BeanDefinitionRegistry beanDefinitionRegistry) { - ApplicationEventPublisher eventPublisher = super.findEventPublisher(beanDefinitionRegistry) return { -> def common = getCommonConfiguration(beanDefinitionRegistry, 'hibernate') common.delegate = delegate @@ -175,13 +170,7 @@ class HibernateDatastoreSpringInitializer extends AbstractDatastoreInitializer { // container can build. Holding the publisher itself puts a live object in the // definition, and generating code for a definition means writing out what it holds -- // which a publisher bound to a running context is not. - if (beanDefinitionRegistry instanceof ConfigurableApplicationContext - || resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext) { - grailsDatastoreEventPublisher(ConfigurableApplicationContextEventPublisher) - } - else { - grailsDatastoreEventPublisher(DefaultApplicationEventPublisher) - } + grailsDatastoreEventPublisher(findEventPublisherClass(beanDefinitionRegistry)) dataSourceConnectionSourceFactory(CachedDataSourceConnectionSourceFactory) hibernateConnectionSourceFactory(HibernateConnectionSourceFactory, ref('hibernateBytecodeProvider'), persistentClasses as Class[]) { bean -> bean.autowire = true diff --git a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy index f2ecd46356d..9bce4aec102 100644 --- a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy +++ b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy @@ -22,14 +22,11 @@ import com.mongodb.client.MongoClient import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.context.ApplicationContext -import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.support.GenericApplicationContext import org.springframework.util.ClassUtils import grails.mongodb.MongoEntity import org.grails.datastore.gorm.bootstrap.AbstractDatastoreInitializer -import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher -import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher import org.grails.datastore.gorm.plugin.support.PersistenceContextInterceptorAggregator import org.grails.datastore.gorm.support.AbstractDatastorePersistenceContextInterceptor import org.grails.datastore.gorm.support.DatastorePersistenceContextInterceptor @@ -92,13 +89,7 @@ class MongoDbDataStoreSpringInitializer extends AbstractDatastoreInitializer { // datastore holds a reference the container can build, which is what lets the context // be processed ahead of time. Outside an application context there is nothing to // publish through, so the no-op publisher stands in as it did before. - if (beanDefinitionRegistry instanceof ConfigurableApplicationContext - || resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext) { - grailsDatastoreEventPublisher(ConfigurableApplicationContextEventPublisher) - } - else { - grailsDatastoreEventPublisher(DefaultApplicationEventPublisher) - } + grailsDatastoreEventPublisher(findEventPublisherClass(beanDefinitionRegistry)) // The configuration is referenced rather than passed. Passing it puts the resolver // itself in the definition, and generating code for a definition means writing out // whatever it holds: an environment carries the machine's own variables, so the diff --git a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy index d8552a19400..51799eae531 100644 --- a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy +++ b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy @@ -38,7 +38,6 @@ import org.grails.datastore.mapping.services.ServiceDefinition import org.grails.datastore.mapping.services.SoftServiceLoader import org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader import org.springframework.beans.factory.support.BeanDefinitionRegistry -import org.springframework.context.ApplicationEventPublisher import org.springframework.context.ConfigurableApplicationContext import org.springframework.util.ClassUtils @@ -75,18 +74,23 @@ class Neo4jDataStoreSpringInitializer extends AbstractDatastoreInitializer { callable.delegate = delegate callable.call() - ApplicationEventPublisher eventPublisher - if (beanDefinitionRegistry instanceof ConfigurableApplicationContext) { - eventPublisher = new ConfigurableApplicationContextEventPublisher((ConfigurableApplicationContext) beanDefinitionRegistry) - } else { - eventPublisher = new DefaultApplicationEventPublisher() - } + // Registered rather than built here, so what the datastore holds is a reference the + // container can build. Holding the publisher itself puts a live object in the + // definition, and generating code for a definition means writing out what it holds -- + // which a publisher bound to a running context is not. + // + // The choice is made here rather than through AbstractDatastoreInitializer, because this + // build resolves that class from a released grails-datamapping-core rather than from + // the source beside it, and a method added there is not one this can call. + grailsDatastoreEventPublisher(beanDefinitionRegistry instanceof ConfigurableApplicationContext + ? ConfigurableApplicationContextEventPublisher + : DefaultApplicationEventPublisher) final boolean isRecentGrailsVersion = GrailsVersion.isAtLeastMajorMinor(3, 3) neo4jConnectionSourceFactory(Neo4jConnectionSourceFactory) { bean -> bean.autowire = true } Object configurationReference = configurationReference(beanDefinitionRegistry) - neo4jDatastore(Neo4jDatastore, configurationReference, ref("neo4jConnectionSourceFactory"), eventPublisher, collectMappedClasses(DATASTORE_TYPE)) + neo4jDatastore(Neo4jDatastore, configurationReference, ref("neo4jConnectionSourceFactory"), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) neo4jMappingContext(neo4jDatastore: "getMappingContext") neo4jTransactionManager(neo4jDatastore: "getTransactionManager") neo4jAutoTimestampEventListener(neo4jDatastore: "getAutoTimestampEventListener") diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy index 977d62336e1..cb8c4295c09 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy @@ -175,6 +175,26 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { return eventPublisher } + /** + * Finds the publisher class a datastore definition should name, in place of a publisher itself. + * + *

    The same choice {@link #findEventPublisher} makes -- one that publishes through the + * surrounding context, or the one that publishes nowhere -- but left to the container to build. + * A definition holding an already-constructed publisher is a definition that cannot be generated + * ahead of time: generating one means writing out what it holds, and a publisher bound to a + * running context is not something there is any way to write down.

    + * + * @param beanDefinitionRegistry the registry the definitions are being contributed to + * @return the class to register the publisher bean under + */ + protected Class findEventPublisherClass(BeanDefinitionRegistry beanDefinitionRegistry) { + if (beanDefinitionRegistry instanceof ConfigurableApplicationContext || + resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext) { + return ConfigurableApplicationContextEventPublisher + } + return DefaultApplicationEventPublisher + } + /** * Finds the message source to use * @param beanDefinitionRegistry The registry diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy index 992bc95666b..a9641fa75b9 100644 --- a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy +++ b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy @@ -21,12 +21,16 @@ package org.grails.datastore.gorm.bootstrap import org.springframework.beans.factory.config.RuntimeBeanReference import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.beans.factory.support.DefaultListableBeanFactory +import org.springframework.context.ApplicationEventPublisher import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.aot.AbstractAotProcessor import org.springframework.context.support.GenericApplicationContext import org.springframework.core.env.MapPropertySource import spock.lang.Specification +import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher +import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher + /** * Covers what a datastore's bean definition holds in place of the configuration. * @@ -104,6 +108,34 @@ class AbstractDatastoreInitializerConfigurationSpec extends Specification { initializer.mappedClassesFor('mongo').toList() == [String, Integer] } + void 'inside a container the publisher class that publishes through it is named'() { + given: + Initializer initializer = new Initializer([:]) + + expect: 'a class for the container to build, rather than a publisher built here -- which is ' + + 'a live object, and a definition holding one cannot be generated ahead of time' + initializer.eventPublisherClassFor(context) == ConfigurableApplicationContextEventPublisher + } + + void 'outside a container the publisher that publishes nowhere is named'() { + given: + Initializer initializer = new Initializer([:]) + + expect: 'the context-aware one would never be given a context here, and would fail on publish' + initializer.eventPublisherClassFor(new DefaultListableBeanFactory()) == + DefaultApplicationEventPublisher + } + + void 'the resource loader stands in for a registry that is not a container'() { + given: 'how a datastore initialized against a bare registry still reaches the context' + Initializer initializer = new Initializer([:]) + initializer.setResourceLoader(context) + + expect: + initializer.eventPublisherClassFor(new DefaultListableBeanFactory()) == + ConfigurableApplicationContextEventPublisher + } + /** Reaches the protected members through a subclass, the way a datastore's own initializer does. */ static class Initializer extends AbstractDatastoreInitializer { @@ -115,6 +147,10 @@ class AbstractDatastoreInitializerConfigurationSpec extends Specification { configurationReference(registry) } + Class eventPublisherClassFor(BeanDefinitionRegistry registry) { + findEventPublisherClass(registry) + } + Class[] mappedClassesFor(String datastoreType) { collectMappedClasses(datastoreType) } From 4016bae65d9781a7da0e160ad1f1fc203ae21abe Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:50:01 -0600 Subject: [PATCH 078/115] Keep the image to the properties files something actually reads Registering **/*.properties carried every properties file at every depth into the image -- every dependency's own configuration, and whatever else was packaged beside it -- to keep the few that are message bundles. Nothing reads a bundle below the root. PluginAwareResourceBundleMessageSource scans classpath*:*.properties, and a plugin shipping its own lands them there too, so *.properties is the pattern and it stays. An application reading something else by name says so on the task that generates the code, since this runs while the code is being generated rather than while the application is running: tasks.named('processAot') { systemProperty 'grails.aot.resource-patterns', 'db/migration/**' } This was the one hints registrar of the six with no spec at all. Writing one found that a list given as 'a, b' registered a pattern with a leading space, which matches nothing and says so nowhere. --- .../beans/aot/GrailsResourceRuntimeHints.java | 64 +++++++++-- .../aot/GrailsResourceRuntimeHintsSpec.groovy | 100 ++++++++++++++++++ 2 files changed, 155 insertions(+), 9 deletions(-) create mode 100644 grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java index 5bdd40f3295..6eb63af240d 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java @@ -18,9 +18,12 @@ */ package org.grails.spring.beans.aot; +import org.jspecify.annotations.Nullable; + import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; -import org.springframework.lang.Nullable; +import org.springframework.core.SpringProperties; +import org.springframework.util.StringUtils; /** * The resources a Grails application reads by name at run time, which an image cannot prove are @@ -34,20 +37,63 @@ * experimental and GraalVM now warns it will require unlocking, while hints are the supported way * and are what Spring writes the image's resource configuration from.

    * + *

    Bounded to where those two are actually looked for. A pattern that matched every properties + * file at every depth would carry the whole classpath into the image -- every dependency's + * configuration, and whatever else happened to be packaged beside it -- to keep the few that are + * message bundles.

    + * * @since 8.0 */ public class GrailsResourceRuntimeHints implements RuntimeHintsRegistrar { + /** + * Where a message bundle is looked for: the root of the classpath, which is what + * {@code PluginAwareResourceBundleMessageSource} scans and where a plugin's own bundles land. + * Not below it, because nothing reads them there. + */ + private static final String MESSAGE_BUNDLES = "*.properties"; + + /** Compiled assets, which asset-pipeline serves from the classpath by the path asked for. */ + private static final String[] ASSETS = { "assets/*", "assets/**" }; + + /** + * Where an application says what else it reads by name, as a comma-separated list of patterns. + * Read as a property rather than from configuration because this runs while the code is being + * generated rather than while the application is running, so it is set on the task that does + * the generating: + * + * 
    +     * tasks.named('processAot') {
+     *     systemProperty 'grails.aot.resource-patterns', 'db/migration/**,templates/*.vm'
+     * }
+     *
    + */ + public static final String ADDITIONAL_PATTERNS_PROPERTY = "grails.aot.resource-patterns"; + @Override public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { - // Compiled assets, which asset-pipeline serves from the classpath by the path asked for. - hints.resources().registerPattern("assets/*"); - hints.resources().registerPattern("assets/**"); - - // Message bundles, chosen by the locale of the request. At the root of the classpath and, - // for a plugin that ships its own, below it. - hints.resources().registerPattern("*.properties"); - hints.resources().registerPattern("**/*.properties"); + for (String pattern : ASSETS) { + hints.resources().registerPattern(pattern); + } + hints.resources().registerPattern(MESSAGE_BUNDLES); + for (String pattern : additionalPatterns()) { + hints.resources().registerPattern(pattern); + } + } + + /** + * What the application asked for on top of the above, or none where it asked for nothing. + * + *

    Tokenized rather than split, so that a list written with spaces after its commas is the + * list it looks like: a pattern carrying a leading space matches nothing, and does so silently, + * leaving out exactly the resource the application asked to keep.

    + */ + private String[] additionalPatterns() { + String configured = SpringProperties.getProperty(ADDITIONAL_PATTERNS_PROPERTY); + if (!StringUtils.hasText(configured)) { + return new String[0]; + } + return StringUtils.tokenizeToStringArray(configured, ","); } } diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy new file mode 100644 index 00000000000..c2a4c9f4470 --- /dev/null +++ b/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy @@ -0,0 +1,100 @@ +/* + * 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.grails.spring.beans.aot + +import org.springframework.aot.hint.RuntimeHints +import org.springframework.core.SpringProperties +import spock.lang.Specification + +/** + * Covers the resources an application reads by name surviving into an image, and only those. + * + *

    An asset is asked for by request path and a message bundle by locale, so nothing in the code + * names either and an image built without them serves every page with a missing stylesheet and an + * untranslated string. What is registered has to be bounded all the same: a pattern matching every + * properties file at every depth carries the whole classpath into the image to keep the few that + * are bundles.

    + */ +class GrailsResourceRuntimeHintsSpec extends Specification { + + RuntimeHints hints = new RuntimeHints() + + void cleanup() { + SpringProperties.setProperty(GrailsResourceRuntimeHints.ADDITIONAL_PATTERNS_PROPERTY, null) + } + + /** + * What was registered. Spring records the parent directory of each pattern alongside it, so + * these are what was asked for and not only what this class named. + */ + private Set registeredPatterns() { + new GrailsResourceRuntimeHints().registerHints(hints, getClass().classLoader) + hints.resources().resourcePatternHints().toList() + .collectMany { it.includes } + .collect { it.pattern } as Set + } + + void 'the compiled assets are registered'() { + expect: 'asset-pipeline serves them from the classpath by the path that was asked for' + registeredPatterns().containsAll(['assets/*', 'assets/**']) + } + + void 'the message bundles at the root of the classpath are registered'() { + expect: 'which is what PluginAwareResourceBundleMessageSource scans, and where a plugin ' + + "shipping its own bundle lands them" + '*.properties' in registeredPatterns() + } + + void 'every properties file on the classpath is not'() { + expect: 'nothing reads a bundle below the root, and registering the pattern would carry ' + + 'every dependency configuration into the image to keep the few that are bundles' + !('**/*.properties' in registeredPatterns()) + } + + void 'an application says what else it reads by name'() { + given: + SpringProperties.setProperty(GrailsResourceRuntimeHints.ADDITIONAL_PATTERNS_PROPERTY, + 'db/migration/**,templates/*.vm') + + expect: 'read as a property because this runs while the code is being generated' + registeredPatterns().containsAll(['db/migration/**', 'templates/*.vm']) + } + + void 'a list written with spaces after its commas is the list it looks like'() { + given: + SpringProperties.setProperty(GrailsResourceRuntimeHints.ADDITIONAL_PATTERNS_PROPERTY, + 'db/migration/**, templates/*.vm ,') + + expect: 'a pattern carrying a leading space matches nothing, and does so silently' + registeredPatterns().containsAll(['db/migration/**', 'templates/*.vm']) + !registeredPatterns().any { it != it.trim() } + } + + void 'an application that says nothing gets what it would have'() { + given: + SpringProperties.setProperty(GrailsResourceRuntimeHints.ADDITIONAL_PATTERNS_PROPERTY, blank) + + expect: + registeredPatterns().containsAll(['assets/*', 'assets/**', '*.properties']) + !('db/migration/**' in registeredPatterns()) + + where: + blank << [null, '', ' '] + } +} From 48d9d2b37ad363363309e4fd29a1e92f8113b526 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:50:10 -0600 Subject: [PATCH 079/115] Tell Gradle what decides whether the views are staged Whether any controller is scaffolded is read from the sources while the build is configured, and it shapes the task graph: the tasks that expand and stage the scaffolded views exist only when the answer is yes. Read by opening the files directly it was an input Gradle knew nothing about, so the answer was settled once, kept in the configuration cache, and a controller that became scaffolded afterwards did not get the tasks that generate its views. Asked through a ValueSource instead. Gradle re-runs one on every build and drops the cached configuration when its answer changes. Why the match stays loose is now written down rather than left to be discovered: the generation task reads the real annotation off the compiled class with ASM, so a false positive here costs a copy and a task that writes nothing, while a false negative costs a view that is missing from the artifact. --- .../plugin/views/gsp/GroovyPagePlugin.groovy | 53 ++++++++++++++----- 1 file changed, 39 insertions(+), 14 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy index 70b7f01189a..fa980893baa 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/views/gsp/GroovyPagePlugin.groovy @@ -25,12 +25,16 @@ import org.gradle.api.Project import org.gradle.api.plugins.BasePlugin import org.gradle.api.tasks.Sync import org.gradle.api.tasks.util.PatternFilterable +import org.gradle.api.file.ConfigurableFileCollection import org.gradle.api.file.CopySpec import org.gradle.api.file.Directory import org.gradle.api.file.DuplicatesStrategy import org.gradle.api.file.FileCollection import org.gradle.api.plugins.JavaPluginExtension import org.gradle.api.provider.Provider +import org.gradle.api.provider.ValueSource +import org.gradle.api.provider.ValueSourceParameters +import org.gradle.api.provider.ValueSourceSpec import org.gradle.api.tasks.SourceSet import org.gradle.api.tasks.SourceSetOutput import org.gradle.api.tasks.TaskContainer @@ -91,7 +95,7 @@ class GroovyPagePlugin implements Plugin { // Only a project that scaffolds pays for this. Staging copies the views, and pointing the // compilation at the copy would change what every other project compiles for no reason. Directory appViews = project.layout.projectDirectory.dir('grails-app/views') - boolean scaffolds = scaffoldsAnyController(project) + boolean scaffolds = scaffoldsAnyController(project).get() Directory viewsToCompile = appViews if (scaffolds) { @@ -202,22 +206,43 @@ class GroovyPagePlugin implements Plugin { } /** - * Whether any controller in this project is scaffolded, read from the sources because the - * decision is needed before anything is compiled. A project that does not scaffold compiles its - * views where they are, as it did before. + * Whether any controller in this project is scaffolded, which decides whether the views are + * staged before they are compiled. The answer is needed while the build is being configured, + * before anything has been compiled, so it is read from the sources. + * + *

    Read through a {@link ValueSource} rather than by opening the files here. Gradle re-runs a + * value source on every build and invalidates the configuration cache when its answer changes, + * so a controller that becomes scaffolded rebuilds the graph that generates its views. Read + * directly, the answer would be an undeclared input: settled once, cached, and wrong from then + * on.

    + * + *

    The match is deliberately loose. {@link GenerateScaffoldedViewsTask} reads the real + * annotation from the compiled class, so a false positive here costs a staging copy and a + * generation task that writes nothing -- while a false negative costs a view that is missing + * from the artifact, found by whoever opens that page.

    */ - protected boolean scaffoldsAnyController(Project project) { - File controllers = project.layout.projectDirectory.dir('grails-app/controllers').asFile - if (!controllers.isDirectory()) { - return false + protected Provider scaffoldsAnyController(Project project) { + project.providers.of(ScaffoldedControllers) { ValueSourceSpec spec -> + spec.parameters.controllers.from( + project.fileTree(project.layout.projectDirectory.dir('grails-app/controllers')) + .matching { PatternFilterable p -> p.include('**/*.groovy') }) } - boolean found = false - controllers.eachFileRecurse { File file -> - if (!found && file.name.endsWith('.groovy') && file.text.contains('@Scaffold')) { - found = true - } + } + + /** Reads the controller sources for the mark of a scaffolded one, as a tracked build input. */ + abstract static class ScaffoldedControllers implements ValueSource { + + interface Parameters extends ValueSourceParameters { + + ConfigurableFileCollection getControllers() + + } + + @Override + Boolean obtain() { + parameters.controllers.files.any { File controller -> controller.text.contains('@Scaffold') } } - found + } protected FileCollection resolveClassesDirs(SourceSetOutput output, Project project) { From 9bbd56625c163fe6697ff35efe263ca16b8a8ddd Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:50:19 -0600 Subject: [PATCH 080/115] Say which JDK a cache needs, rather than let the run fail for it -XX:AOTCacheOutput arrived in JDK 25. An earlier one does not recognise it and stops at once, so the build reported that the application had ended before it started serving and named a log of a start-up that never happened. That reads as a broken application rather than as the wrong JDK, which is the symptom the task's own javadoc already describes running into. Asked of the toolchain the training will run on rather than of the JDK running Gradle, beside the refusal on Windows and for the same reason: said before the run rather than discovered after it. A version string it cannot read is left to the run to answer for. Refusing over one would fail a build on a JDK that may be perfectly capable. --- .../plugin/aot/TrainAotCacheTask.groovy | 39 +++++++++++++++++ .../plugin/aot/TrainAotCacheTaskSpec.groovy | 43 +++++++++++++++++++ 2 files changed, 82 insertions(+) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index f2566c1f9cc..90bbd0ed5bb 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -101,9 +101,13 @@ abstract class TrainAotCacheTask extends DefaultTask { @OutputFile abstract RegularFileProperty getMetadataFile() + /** The first JDK that can write one. Before it, {@code -XX:AOTCacheOutput} is not an option. */ + private static final int MINIMUM_JAVA_VERSION = 25 + @TaskAction void train() { refuseWhereTheRunCannotBeAskedToStop() + refuseWhereTheJdkCannotWriteACache() File directory = applicationDirectory.get().asFile File cache = cacheFile.get().asFile cache.delete() @@ -179,6 +183,41 @@ abstract class TrainAotCacheTask extends DefaultTask { } } + /** + * Refuses on a JDK that has no cache to write, before the run is started. + * + *

    {@code -XX:AOTCacheOutput} arrived in JDK 25. An earlier JDK does not recognise it and + * stops immediately, so the run would be started, fail at once, and be reported as having + * ended before it started serving -- which reads as a broken application rather than as the + * wrong JDK, and sends whoever is reading the build into a log of the application's own + * start-up that never happened.

    + * + *

    Asked of the JDK the training will run on, which is the project's toolchain rather than + * whichever one is running Gradle.

    + */ + private void refuseWhereTheJdkCannotWriteACache() { + String version = javaVersion.get() + Integer major = majorVersionOf(version) + if (major != null && major < MINIMUM_JAVA_VERSION) { + throw new GradleException("Training an AOT cache needs Java ${MINIMUM_JAVA_VERSION} or " + + "later, and the toolchain this would train on is ${version}. Point the project " + + 'toolchain at a newer JDK, or set grails.aotCache.enabled to false.') + } + } + + /** + * The feature version of a runtime version string, or {@code null} where it does not begin with + * one. Unreadable rather than old: a version this cannot parse is left to the run to answer for, + * since refusing over it would fail a build on a JDK that may be perfectly capable. + */ + private static Integer majorVersionOf(String version) { + int digits = 0 + while (digits < version.length() && Character.isDigit(version.charAt(digits))) { + digits++ + } + digits > 0 ? Integer.valueOf(version.substring(0, digits)) : null + } + /** * Writes down what the cache was made from. * diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index d7afeb4e85c..35a68516fb6 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -291,4 +291,47 @@ exit 1 cleanup: System.setProperty('os.name', os) } + + void 'a run is refused on a JDK that has no cache to write'() { + given: 'the toolchain the training would run on, which is not the one running the build' + TrainAotCacheTask task = task('not-an-archive.jar', []) + task.javaVersion.set('21.0.12+10') + + when: + task.train() + + then: 'said as the wrong JDK, rather than as an application that ended before it served' + GradleException e = thrown() + e.message.contains('Java 25 or later') + e.message.contains('21.0.12+10') + } + + void 'a JDK that can write one is not refused'() { + given: + TrainAotCacheTask task = task('not-an-archive.jar', []) + task.javaVersion.set(version) + + when: + task.train() + + then: 'it gets as far as running, which is where this spec stops caring' + GradleException e = thrown() + !e.message.contains('Java 25 or later') + + where: + version << ['25.0.1+9', '26', '31.0.2+7'] + } + + void 'a version that cannot be read is left to the run to answer for'() { + given: 'refusing over an unreadable version would fail a build on a capable JDK' + TrainAotCacheTask task = task('not-an-archive.jar', []) + task.javaVersion.set('a vendor string nobody parsed') + + when: + task.train() + + then: + GradleException e = thrown() + !e.message.contains('Java 25 or later') + } } From e517a9d7b4bc1ff45bd9fd07eabfc3afea6fffd6 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:50:27 -0600 Subject: [PATCH 081/115] Say which banner version option was not recognised A configured option that named nothing was dropped without a word, so a name with a typo in it read as a banner quietly ignoring what it was told, and the only way to find out was to notice a line that was not there. Which list an option belongs to is no longer asked either. An application names one to say it wants a version or does not, and moving an option between the shown-by-default set and the asked-for set is this class's decision -- so an application that asked for spring-security before it became a default said something recognisable and should not be told it did not. That leaves the three properties reading the same way, so the filter each of them was passed is gone. Said after the banner rather than while one is being built. A line logged partway through arrives between the mark and the versions, which is the very thing reading a version without initialising the library it belongs to was for. --- .../boot/GrailsBannerVersionLookupSpec.groovy | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy index 30e18ac581d..f018478bedb 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerVersionLookupSpec.groovy @@ -185,4 +185,42 @@ class GrailsBannerVersionLookupSpec extends Specification { then: bytes.toString().count('Tomcat') == 1 } + + void 'an option that has moved between the lists is still recognised'() { + expect: 'spring-security was asked for before it was shown by default, and an application ' + + 'that still asks for it named something this understands' + new Serving().unrecognisedVersionOptions( + configured(['grails.banner.versions.include': 'spring-security'])).isEmpty() + } + + void 'an option shown by default can be named in either list'() { + expect: 'which list an option belongs to is this class\'s decision to change, so naming one ' + + 'is not a mistake an application made' + new Serving().unrecognisedVersionOptions(configured([ + 'grails.banner.versions.include': 'container', + 'grails.banner.versions.exclude': 'tomcat'])).isEmpty() + } + + void 'an option that names nothing is reported'() { + expect: 'dropped silently, a typo reads as a banner ignoring what it was told, and the only ' + + 'way to find out is to notice a line that is not there' + new Serving().unrecognisedVersionOptions( + configured(['grails.banner.versions.include': 'spring-securty'])) == ['spring-securty'] + } + + void 'every place an option can be written is checked'() { + expect: + new Serving().unrecognisedVersionOptions(configured([ + 'grails.banner.versions.order': 'grails,ordr', + 'grails.banner.versions.exclude': 'excloode', + 'grails.banner.versions.include': 'includ'])) == ['ordr', 'excloode', 'includ'] + } + + void 'an application that named them all correctly is told nothing'() { + expect: + new Serving().unrecognisedVersionOptions(configured([ + 'grails.banner.versions.order': 'grails,groovy', + 'grails.banner.versions.exclude': 'app', + 'grails.banner.versions.include': 'jetty'])).isEmpty() + } } From 6fa81e7777969c97fdeea95ba9bb18092f9f2d1d Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Tue, 11 Aug 2026 23:50:36 -0600 Subject: [PATCH 082/115] Write down what the banner now says without being asked The banner reports the servlet container and, where the application has it, the version of Spring Security, neither of which it reported before. Both were opt-in because a version that could not be determined was shown as 'unknown', and turning one on by default would have printed that for every application without it; a version that cannot be determined is now left out instead, which is what allows them to be shown and also means one explicitly asked for no longer appears as 'unknown' but not at all. Every application's banner changes, so the upgrade guide says how to restore the previous output and confirms that an application already asking for spring-security needs no change. The rest of the release had nothing about ahead-of-time processing, the cache it can train, or the banner's colour and start mark either. --- .../src/en/guide/introduction/whatsNew.adoc | 60 +++++++++++++++++++ .../src/en/guide/upgrading/upgrading80x.adoc | 37 ++++++++++++ 2 files changed, 97 insertions(+) diff --git a/grails-doc/src/en/guide/introduction/whatsNew.adoc b/grails-doc/src/en/guide/introduction/whatsNew.adoc index aa8b28f1b17..3481d2f719a 100644 --- a/grails-doc/src/en/guide/introduction/whatsNew.adoc +++ b/grails-doc/src/en/guide/introduction/whatsNew.adoc @@ -277,3 +277,63 @@ be enabled (`grails.mongodb.transactional = true`). Spring Data repositories are session are shared, and the two object-mapping models stay separate. See the link:{mongodb5Guide}index.html#springDataInterop[Spring Data MongoDB Interoperability] section of the GORM for MongoDB guide for details. + +==== Ahead-of-Time Processing + +A Grails application can now be processed by Spring's ahead-of-time engine. Applying Spring Boot's AOT plugin adds a +`processAot` task, which generates the bean definitions as Java source at build time instead of deriving them from +classpath scanning and annotations on every start: + +[source,groovy] +.build.gradle +---- +apply plugin: 'org.springframework.boot.aot' + +tasks.named('processAot') { + systemProperty 'grails.env', 'production' +} +---- + +[source,bash] +---- +java -Dspring.aot.enabled=true -jar build/libs/myapp.jar +---- + +AOT processing is also what a GraalVM native image requires: Spring Boot refuses to start an image without a +build-time generated initializer. Reachability metadata for the application's own artefacts and compiled pages is +written from the build output, and `traceNativeMetadata` records what the framework reflects on along a request path. + +See the xref:deployment/deploymentAot[Ahead-of-Time Processing] section for what it changes at runtime and what it +does not yet cover. + +==== Ahead-of-Time Caching + +On JDK 25 or later, `grails.aotCache` trains a JDK AOT cache by running the packaged application once and recording +the classes it loaded and linked and the methods it ran, so the next start reads that work rather than repeating it: + +[source,groovy] +.build.gradle +---- +grails { + aotCache { + enabled = true + paths = ['/', '/login', '/book/index'] + } +} +---- + +See the xref:deployment/deploymentAotCache[Ahead-of-Time Caching] section, which includes measured figures and the +conditions under which a JVM will decline a cache. + +==== Banner Colour, Container Version and Start Mark + +The startup banner is coloured, reports the servlet container it is running on, and says how the application was +started where that is worth saying — `NATIVE` for an image, `AOT CACHE` for a JVM given a cache to read, `AOT` for one +running generated bean definitions. An ordinary start says nothing. + +Spring Security and the servlet container are also shown by default now. What allows that is a smaller change +underneath: a version that cannot be determined is left out of the banner rather than shown as `unknown`, so an +application without Spring Security says nothing about it instead of saying it does not know. See +xref:conf/applicationClass/customizing[Customizing the Application Class] for the full set of banner options, and the +xref:upgrading#upgrading80x[upgrade guide] for how to restore the previous output. + diff --git a/grails-doc/src/en/guide/upgrading/upgrading80x.adoc b/grails-doc/src/en/guide/upgrading/upgrading80x.adoc index 2d777e80ccb..ab95bfefd4d 100644 --- a/grails-doc/src/en/guide/upgrading/upgrading80x.adoc +++ b/grails-doc/src/en/guide/upgrading/upgrading80x.adoc @@ -2255,3 +2255,40 @@ resolved unambiguously before can become ambiguous. Removing the packages from `grails.spring.bean.packages`, or the stray classes from those packages, restores the previous set of beans. + +==== 45. Startup Banner Shows the Servlet Container and Spring Security + +The banner now reports the servlet container it is running on, and the version of Spring Security where the +application has it, without being asked for either. Both were previously opt-in through +`grails.banner.versions.include`. + +What made them opt-in was that a version which could not be determined was shown as `unknown`, so turning one +on by default would have printed `Spring Security: unknown` for every application without it. A version that +cannot be determined is now left out of the banner entirely, which is what allows the two to be shown by +default — and which also means a version explicitly asked for, but not resolvable, no longer appears as +`unknown`. It appears not at all. + +The container is named as itself: an application on Tomcat shows `Tomcat`, one on Jetty shows `Jetty`. It is +configured under the single key `container`, whichever container that turns out to be. + +To restore the previous banner, exclude them: + +[source, yaml] +.grails-app/conf/application.yml +---- +grails: + banner: + versions: + exclude: + - container + - spring-security +---- + +An application that already asked for `spring-security` under `grails.banner.versions.include` keeps working +and needs no change — the option is still recognised, and the version is shown either way. The same is true +of `tomcat`, `jetty` and `undertow`, which remain available for an application that wants to be told about a +particular container whether or not it is the one serving; naming one as well as taking the default shows it +once, not twice. + +A version option that names none of the known keys is now reported as a warning after the banner is printed, +rather than being dropped in silence. From 1d95c8eff252220bc70ba20101cd47ce8f6b1d3c Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 10:33:48 -0600 Subject: [PATCH 083/115] Leave collectMappedClasses saying what it has always said It had been changed to return Class[], which the array a datastore's constructor takes has to be for the argument to survive being written out as code. But it is also the seam a datastore outside this repository overrides to say which of the classes are its own, and a subclass overriding it to return a collection no longer overrides anything: it compiles as a separate method, is never called, and the datastore quietly maps whatever the parent decided. So the array is a second method that asks the first, and an override keeps being asked. Only what goes into the definition changed. --- .../MongoDbDataStoreSpringInitializer.groovy | 4 +-- .../AbstractDatastoreInitializer.groovy | 27 +++++++++++++++---- ...tastoreInitializerConfigurationSpec.groovy | 24 ++++++++++++++++- 3 files changed, 47 insertions(+), 8 deletions(-) diff --git a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy index 9bce4aec102..87b02fe42bc 100644 --- a/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy +++ b/grails-data-mongodb/core/src/main/groovy/grails/mongodb/bootstrap/MongoDbDataStoreSpringInitializer.groovy @@ -100,11 +100,11 @@ class MongoDbDataStoreSpringInitializer extends AbstractDatastoreInitializer { mongoConnectionSourceFactory(MongoConnectionSourceFactory) { bean -> bean.autowire = true } - mongoDatastore(MongoDatastore, configurationReference, ref('mongoConnectionSourceFactory'), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) + mongoDatastore(MongoDatastore, configurationReference, ref('mongoConnectionSourceFactory'), ref('grailsDatastoreEventPublisher'), mappedClasses(DATASTORE_TYPE)) mongo(mongoDatastore: 'getMongoClient') } else { - mongoDatastore(MongoDatastore, mongo, configurationReference, ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) + mongoDatastore(MongoDatastore, mongo, configurationReference, ref('grailsDatastoreEventPublisher'), mappedClasses(DATASTORE_TYPE)) } mongoMappingContext(mongoDatastore: 'getMappingContext') diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy index cb8c4295c09..6655a7f1756 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy @@ -316,6 +316,18 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { return {} } + /** + * The classes this datastore maps. + * + * @param datastoreType the datastore the classes are being collected for + * @return the classes, which a datastore's definition takes through {@link #mappedClasses} + */ + protected Collection collectMappedClasses(String datastoreType) { + !secondaryDatastore ? persistentClasses : persistentClasses.findAll() { Class cls -> + isMappedClass(datastoreType, cls) + } + } + /** * The classes this datastore maps, as the array its constructor takes. * @@ -325,12 +337,17 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { * {@code Class[]}, so the lookup misses it and the argument is resolved as a dependency instead, * which for an array type means every {@code Class} bean in the context: none. The datastore is * then built mapping nothing, and the first call on a domain class reports that it is not one.

    + * + *

    Kept apart from {@link #collectMappedClasses} rather than folded into it, because that one + * is the seam a datastore outside this repository overrides to say which classes are its own. + * Changing what it returns would leave such an override no longer overriding anything, and + * silently unasked.

    + * + * @param datastoreType the datastore the classes are being collected for + * @return the classes, as the array a datastore's constructor takes */ - protected Class[] collectMappedClasses(String datastoreType) { - Collection classes = !secondaryDatastore ? persistentClasses : persistentClasses.findAll() { Class cls -> - isMappedClass(datastoreType, cls) - } - return classes as Class[] + protected Class[] mappedClasses(String datastoreType) { + collectMappedClasses(datastoreType) as Class[] } protected boolean isMappedClass(String datastoreType, Class cls) { diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy index a9641fa75b9..034f8a0dd94 100644 --- a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy +++ b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializerConfigurationSpec.groovy @@ -108,6 +108,15 @@ class AbstractDatastoreInitializerConfigurationSpec extends Specification { initializer.mappedClassesFor('mongo').toList() == [String, Integer] } + void 'a datastore saying which classes are its own is still asked'() { + given: 'the seam a datastore outside this repository overrides' + Initializer initializer = new Overriding([:]) + initializer.persistentClasses = [String, Integer] + + expect: 'folding the array into it would leave such an override overriding nothing' + initializer.mappedClassesFor('mongo').toList() == [Integer] + } + void 'inside a container the publisher class that publishes through it is named'() { given: Initializer initializer = new Initializer([:]) @@ -152,7 +161,7 @@ class AbstractDatastoreInitializerConfigurationSpec extends Specification { } Class[] mappedClassesFor(String datastoreType) { - collectMappedClasses(datastoreType) + mappedClasses(datastoreType) } @Override @@ -165,4 +174,17 @@ class AbstractDatastoreInitializerConfigurationSpec extends Specification { Object } } + + /** A datastore that says which of the classes are its own, the way an implementation does. */ + static class Overriding extends Initializer { + + Overriding(Map configuration) { + super(configuration) + } + + @Override + protected Collection collectMappedClasses(String datastoreType) { + persistentClasses.findAll { Class cls -> cls != String } + } + } } From 082b6b4829db89ae224490598b15056c81ea1bae Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 10:33:56 -0600 Subject: [PATCH 084/115] Ask the post-processor about colour through the hook that decides it The spec reached past postProcessEnvironment for the one method it wanted, which is package-private and was only that so a test in the same package could call it. It now runs the post-processor the way Spring Boot runs it, with plugin discovery that finds none so the rest of the phase completes and does nothing. The method goes back to private, which is what it was describing itself as. --- .../GrailsEnvironmentPostProcessor.java | 2 +- ...ilsEnvironmentPostProcessorAnsiSpec.groovy | 24 ++++++++++++++++--- 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java b/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java index 79648fb61cd..ee823f1a5e7 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java @@ -116,7 +116,7 @@ public void postProcessEnvironment(ConfigurableEnvironment environment, SpringAp * build, a container, a service manager, where the output is only ever read later and stays * plain. An application that has said either way is left alone.

    */ - void colourTheOutputOfAnImageThatHasATerminal(ConfigurableEnvironment environment) { + private void colourTheOutputOfAnImageThatHasATerminal(ConfigurableEnvironment environment) { if (!isImage() || environment.containsProperty(ANSI_ENABLED)) { return; } diff --git a/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy b/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy index c4b4b76b268..97bedd9ac8d 100644 --- a/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy @@ -18,11 +18,15 @@ */ package grails.boot.config +import org.springframework.boot.bootstrap.BootstrapRegistry.InstanceSupplier import org.springframework.boot.bootstrap.DefaultBootstrapContext import org.springframework.core.env.MapPropertySource import org.springframework.core.env.StandardEnvironment import spock.lang.Specification +import org.apache.grails.core.plugins.DefaultPluginDiscovery +import org.apache.grails.core.plugins.PluginDiscovery + /** * Covers an image colouring its output when it is being watched at a terminal. * @@ -38,11 +42,25 @@ class GrailsEnvironmentPostProcessorAnsiSpec extends Specification { StandardEnvironment environment = new StandardEnvironment() + /** + * Runs the post-processor the way Spring Boot runs it, rather than reaching past it for the one + * method under test: whether an image colours its output is only worth knowing about through the + * hook that decides it. + */ private String ansiAfter(boolean image, String terminal) { - new Processor(image, terminal).colourTheOutputOfAnImageThatHasATerminal(environment) + DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext() + bootstrapContext.register(PluginDiscovery, InstanceSupplier.of(noPlugins())) + new Processor(bootstrapContext, image, terminal).postProcessEnvironment(environment, null) environment.getProperty(ANSI) } + /** Plugin discovery that finds none, so the phase this shares with completes and does nothing. */ + private static PluginDiscovery noPlugins() { + DefaultPluginDiscovery discovery = new DefaultPluginDiscovery(new Class[0]) + discovery.loadPluginsFromClasspath = false + discovery + } + void 'an image at a terminal colours its output'() { expect: ansiAfter(true, 'xterm-256color') == 'always' @@ -77,8 +95,8 @@ class GrailsEnvironmentPostProcessorAnsiSpec extends Specification { private final boolean image private final String terminal - Processor(boolean image, String terminal) { - super(new DefaultBootstrapContext()) + Processor(DefaultBootstrapContext bootstrapContext, boolean image, String terminal) { + super(bootstrapContext) this.image = image this.terminal = terminal } From 0a8b8f5022ea201995d00e563004ffedee0c53a1 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 10:34:06 -0600 Subject: [PATCH 085/115] Make the ahead-of-time application serve a page, not only start The check asserted five bean names on an application with no controller, no view, no tag library and no mappings. Nothing it did could have failed for any of the reasons this work exists: almost everything an application generated ahead of time gets wrong is something that starts perfectly well and goes wrong on the first request. So the application has a page now, and the check asks for it. Rendering it needs the tag library to have been given the collaborator it takes by name, the page to have been found in the manifest of pages compiled at build time, the action to have reached the view it returned, and the mappings to have routed the request at all. The link on it is followed rather than compared against a path written here, since what the generator produces is whatever the mappings reverse to -- so the question worth asking is whether the link leads back to the page it was built on. It also asserts a bean contributed by a plugin's @Configuration class, which is what tells us the processor the core plugin stands down in favour of did parse them. Confirmed capable of failing: with AutowireModeBeanRegistrationAotProcessor taken out of aot.factories the application still starts, and the request fails on "Cannot invoke method greeting() on null object". --- .../controllers/aot/GreetingController.groovy | 30 +++++++++ .../controllers/aot/UrlMappings.groovy | 29 +++++++++ .../grails-app/init/aot/Application.groovy | 61 +++++++++++++++++-- .../services/aot/GreetingService.groovy | 30 +++++++++ .../taglib/aot/GreetingTagLib.groovy | 38 ++++++++++++ .../aot/grails-app/views/greeting/index.gsp | 35 +++++++++++ 6 files changed, 219 insertions(+), 4 deletions(-) create mode 100644 grails-test-examples/aot/grails-app/controllers/aot/GreetingController.groovy create mode 100644 grails-test-examples/aot/grails-app/controllers/aot/UrlMappings.groovy create mode 100644 grails-test-examples/aot/grails-app/services/aot/GreetingService.groovy create mode 100644 grails-test-examples/aot/grails-app/taglib/aot/GreetingTagLib.groovy create mode 100644 grails-test-examples/aot/grails-app/views/greeting/index.gsp diff --git a/grails-test-examples/aot/grails-app/controllers/aot/GreetingController.groovy b/grails-test-examples/aot/grails-app/controllers/aot/GreetingController.groovy new file mode 100644 index 00000000000..5125b0cca5a --- /dev/null +++ b/grails-test-examples/aot/grails-app/controllers/aot/GreetingController.groovy @@ -0,0 +1,30 @@ +/* + * 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 aot + +/** + * Serves the one page this application has, so that the request path is exercised rather than only + * the start-up: a context that comes up cleanly can still fail on the first thing anyone asks it for. + */ +class GreetingController { + + def index() { + [name: 'ahead of time'] + } +} diff --git a/grails-test-examples/aot/grails-app/controllers/aot/UrlMappings.groovy b/grails-test-examples/aot/grails-app/controllers/aot/UrlMappings.groovy new file mode 100644 index 00000000000..c9c95d37329 --- /dev/null +++ b/grails-test-examples/aot/grails-app/controllers/aot/UrlMappings.groovy @@ -0,0 +1,29 @@ +/* + * 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 aot + +class UrlMappings { + + static mappings = { + "/$controller/$action?/$id?(.$format)?" { } + "/"(controller: 'greeting', action: 'index') + // no 500 or 404 view is mapped: this application exists to fail loudly, and a mapping to a + // page it does not have would answer a real failure with a second one about the error page + } +} diff --git a/grails-test-examples/aot/grails-app/init/aot/Application.groovy b/grails-test-examples/aot/grails-app/init/aot/Application.groovy index e56f66ce0ec..21a35a5c958 100644 --- a/grails-test-examples/aot/grails-app/init/aot/Application.groovy +++ b/grails-test-examples/aot/grails-app/init/aot/Application.groovy @@ -26,10 +26,16 @@ import org.springframework.context.ConfigurableApplicationContext class Application extends GrailsAutoConfiguration { /** - * With {@code --aot-startup-check} the application starts, asserts the beans an AOT-processed - * context must still contain, and exits. The build runs it that way against the packaged jar - * with {@code spring.aot.enabled=true}, so a context that generates cleanly but cannot boot - * fails the build rather than passing unnoticed. + * With {@code --aot-startup-check} the application starts, asks itself for the one page it has, + * and exits. The build runs it that way against the packaged jar with + * {@code spring.aot.enabled=true}. + * + *

    The page is the point. Almost everything an application generated ahead of time gets wrong + * is something that starts perfectly well: a tag library holding null where a collaborator wired + * by name should be, a link generator whose own collaborator was injected into a field of an + * implementation the container only knows as an interface, a page looked up in a manifest an + * image did not carry. None of it is visible until something renders, so a check that only reads + * the bean names would pass while every one of those was broken.

    */ static void main(String[] args) { if (!args.contains('--aot-startup-check')) { @@ -44,6 +50,10 @@ class Application extends GrailsAutoConfiguration { assertBeanPresent(context, 'groovyPagesServlet') assertBeanPresent(context, 'jspViewResolver') assertBeanPresent(context, 'grailsUrlMappingsHolder') + // contributed by a plugin's @Configuration class, which is parsed by the processor the + // core plugin stands down in favour of once the definitions are generated + assertBeanPresent(context, 'propertySourcesPlaceholderConfigurer') + assertPageRenders(context) } finally { context.close() @@ -56,4 +66,47 @@ class Application extends GrailsAutoConfiguration { throw new IllegalStateException("AOT-processed context is missing the '${name}' bean") } } + + /** Asks the running application for its page and checks what came back rendered. */ + private static void assertPageRenders(ConfigurableApplicationContext context) { + Integer port = context.environment.getProperty('local.server.port', Integer) + if (port == null) { + throw new IllegalStateException('The application reported no port, so it is not serving') + } + String page = get(port, '/greeting/index') + assertRendered(page, 'hello from a service', + 'the tag library rendered without the collaborator it takes by name') + assertRendered(page, 'ahead of time', 'the action did not reach the page it returned') + + // Followed rather than matched against a path written here. What the generator produces is + // whatever the mappings reverse to -- this application maps the action to the root -- so the + // question worth asking is whether the link it built leads back to the page it was built on. + String link = between(page, '') + if (!link) { + throw new IllegalStateException("AOT-processed application: the link generator built no " + + "link. Page was:\n${page}") + } + assertRendered(get(port, link), 'hello from a service', + "the link the generator built (${link}) does not lead back to the page") + } + + private static String get(int port, String path) { + new URI("http://localhost:${port}${path}").toURL().getText('UTF-8') + } + + private static String between(String page, String start, String end) { + int from = page.indexOf(start) + if (from < 0) { + return null + } + int to = page.indexOf(end, from + start.length()) + to < 0 ? null : page.substring(from + start.length(), to).trim() + } + + private static void assertRendered(String page, String expected, String whatItMeans) { + if (!page.contains(expected)) { + throw new IllegalStateException( + "AOT-processed application: ${whatItMeans}. Expected '${expected}' in:\n${page}") + } + } } diff --git a/grails-test-examples/aot/grails-app/services/aot/GreetingService.groovy b/grails-test-examples/aot/grails-app/services/aot/GreetingService.groovy new file mode 100644 index 00000000000..1c7a516e1bb --- /dev/null +++ b/grails-test-examples/aot/grails-app/services/aot/GreetingService.groovy @@ -0,0 +1,30 @@ +/* + * 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 aot + +/** + * A collaborator the tag library takes by name, which is how Grails wires most of what it + * contributes: no annotation says to inject this, only that the bean and the property share a name. + */ +class GreetingService { + + String greeting() { + 'hello from a service' + } +} diff --git a/grails-test-examples/aot/grails-app/taglib/aot/GreetingTagLib.groovy b/grails-test-examples/aot/grails-app/taglib/aot/GreetingTagLib.groovy new file mode 100644 index 00000000000..994fe11723d --- /dev/null +++ b/grails-test-examples/aot/grails-app/taglib/aot/GreetingTagLib.groovy @@ -0,0 +1,38 @@ +/* + * 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 aot + +/** + * Renders what the service says. + * + *

    Its collaborator arrives by name rather than by annotation, which is the arrangement the + * generator writes out nothing for -- so a page reaching this tag is what tells the two apart: a + * tag library rebuilt from generated code without its autowire mode holds null here, and says so + * only when something renders it.

    + */ +class GreetingTagLib { + + static namespace = 'aot' + + def greetingService + + def greeting = { attrs -> + out << greetingService.greeting() + } +} diff --git a/grails-test-examples/aot/grails-app/views/greeting/index.gsp b/grails-test-examples/aot/grails-app/views/greeting/index.gsp new file mode 100644 index 00000000000..23d3b75444d --- /dev/null +++ b/grails-test-examples/aot/grails-app/views/greeting/index.gsp @@ -0,0 +1,35 @@ +<%-- + ~ 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. + --%> +<%-- + Every line here is one of the things that only fails once a page is rendered. + + The page itself is found through the manifest of pages compiled at build time, which an image + reads because it cannot compile one. The tag reaches a collaborator wired by name. The link is + built by the link generator, whose own collaborator is injected into a field of an implementation + the container only knows as an interface. The model value proves the action ran. +--%> + + +ahead of time + +

    +

    ${name}

    + + + From 4788cebfc2f492deff869eb02ce2b27312507eb9 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 10:34:14 -0600 Subject: [PATCH 086/115] Say what makes standing down over the configuration processor safe Withholding the plugin's own ConfigurationClassPostProcessor because the context already has one is only correct while the plugin definitions are registered before that one runs, and nothing at the point of the decision says whether they are. They are, and it is a property of how the application started rather than of this registry: the early registration phase is added with addBeanFactoryPostProcessor, so it runs ahead of Spring's own processor, and it runs whenever PluginDiscovery was promoted to the bean factory -- which the bootstrap registry initializer does, from spring.factories, for every SpringApplication. Written down because working it out takes a trace through three classes, and the shape where it would not hold is a context assembled without SpringApplication. --- .../groovy/org/grails/plugins/CoreGrailsPlugin.groovy | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy index bb7668aa486..687382b77d9 100644 --- a/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy +++ b/grails-core/src/main/groovy/org/grails/plugins/CoreGrailsPlugin.groovy @@ -167,6 +167,15 @@ class CoreGrailsPlugin extends Plugin { // registry parses everything a second time, and while code is being generated the two of // them write out the same import-aware post-processor twice, so one registration // replaces the other on every start. + // + // "Registered ahead of it" is what makes standing down safe, and it is a property of how + // the application started rather than of this registry. GrailsEarlyPluginRegistrationPostProcessor + // is added with addBeanFactoryPostProcessor and so runs before Spring's own processor, + // and it runs whenever PluginDiscovery was promoted to the bean factory -- which + // GrailsBootstrapRegistryInitializer does, from spring.factories, for every + // SpringApplication. A context assembled without SpringApplication would have Spring's + // processor already finished by the time these definitions arrive, and would need this + // one; it would also not be a Grails application started any supported way. if (!AotDetector.useGeneratedArtifacts() && !hasConfigurationClassPostProcessor(application)) { registry.registerBean('grailsConfigurationClassPostProcessor', ConfigurationClassPostProcessor) } From 35657c9b02f20e6a53c36fbf0bae4bd8e256d5c1 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 10:59:53 -0600 Subject: [PATCH 087/115] Leave Neo4j holding the configuration it can still reach Naming the environment in place of the configuration is asked through a method added to AbstractDatastoreInitializer by this work. This build resolves that class from a released grails-datamapping-core rather than from the source beside it, and the call sits in an untyped closure -- so it compiles, and throws MissingMethod the first time the datastore is configured. Nothing here is built by anything: the module is absent from the root settings and pins datastoreVersion to a release, so no compilation and no test would have said so. Reverted to what it held before, which works against what it resolves. The registrar and the mapped classes stay as they are; both work against that release. --- .../bootstrap/Neo4jDataStoreSpringInitializer.groovy | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy index 51799eae531..19a7df1e52d 100644 --- a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy +++ b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy @@ -89,8 +89,12 @@ class Neo4jDataStoreSpringInitializer extends AbstractDatastoreInitializer { neo4jConnectionSourceFactory(Neo4jConnectionSourceFactory) { bean -> bean.autowire = true } - Object configurationReference = configurationReference(beanDefinitionRegistry) - neo4jDatastore(Neo4jDatastore, configurationReference, ref("neo4jConnectionSourceFactory"), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) + // The configuration is held rather than named. Naming the environment instead is what + // lets a definition be generated without writing the build machine's own settings into + // it, but that is asked through a method added to AbstractDatastoreInitializer, and this + // build resolves that class from a released grails-datamapping-core rather than from the + // source beside it -- so the call compiles here and goes missing at run time. + neo4jDatastore(Neo4jDatastore, configuration, ref("neo4jConnectionSourceFactory"), ref('grailsDatastoreEventPublisher'), collectMappedClasses(DATASTORE_TYPE)) neo4jMappingContext(neo4jDatastore: "getMappingContext") neo4jTransactionManager(neo4jDatastore: "getTransactionManager") neo4jAutoTimestampEventListener(neo4jDatastore: "getAutoTimestampEventListener") From 5a924d11b82c9ff35ce935c8c8873a84f13136c5 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 11:05:28 -0600 Subject: [PATCH 088/115] Put back the cookie handler the build was using The trace sets the JVM's cookie handler so that a session carries from one request to the next, which is what makes submitting a form that authenticates worth anything. It never put the previous one back, and the JVM here is a daemon that outlives the build -- so every task that ran afterwards inherited it, holding the cookies of an application that had already stopped. Restored in the finally that stops the run, so a trace that threw puts it back too. It is still the JVM's for the duration, so two traces running at once in one daemon would share a store. Taking that away as well means carrying the cookies per connection rather than per JVM, which is a different task's worth of change. --- .../plugin/aot/TraceNativeMetadataTask.groovy | 6 ++++ .../aot/TraceNativeMetadataTaskSpec.groovy | 36 +++++++++++++++++++ 2 files changed, 42 insertions(+) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index 8b044cdc537..9168a8a616e 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -148,6 +148,11 @@ abstract class TraceNativeMetadataTask extends DefaultTask { .start() List answered = [] + // What carries a session from one request to the next, which is how a form that + // authenticates is worth submitting at all. It is the JVM's, and this JVM is a daemon that + // outlives the build -- so it is put back, whether the trace finished or threw. Left set, it + // would be handed to every task that ran afterwards, holding one application's cookies. + CookieHandler inherited = CookieHandler.default try { awaitStarted(process, output) CookieHandler.default = new CookieManager() @@ -155,6 +160,7 @@ abstract class TraceNativeMetadataTask extends DefaultTask { forms.get().each { String path -> answered << submit(path) } } finally { + CookieHandler.default = inherited stop(process) } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy index 8a19fa08848..4c269e027a6 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy @@ -18,6 +18,9 @@ */ package org.grails.gradle.plugin.aot +import java.net.CookieHandler +import java.net.CookieManager + import org.gradle.api.GradleException import org.gradle.api.Project import org.gradle.testfixtures.ProjectBuilder @@ -181,6 +184,39 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ e.message.contains('answered with an error') } + void 'the cookie handler the build had is put back after a trace'() { + given: 'a daemon outlives the build, so what this sets is handed to every task after it' + CookieHandler inherited = new CookieManager() + CookieHandler.default = inherited + TraceNativeMetadataTask task = task(['/'], []) + + when: + task.trace() + + then: + CookieHandler.default.is(inherited) + + cleanup: + CookieHandler.default = null + } + + void 'and after one that failed'() { + given: + CookieHandler inherited = new CookieManager() + CookieHandler.default = inherited + TraceNativeMetadataTask task = task(['/broken'], []) + + when: + task.trace() + + then: + thrown(GradleException) + CookieHandler.default.is(inherited) + + cleanup: + CookieHandler.default = null + } + void 'a java without the agent is refused before the application is started'() { given: 'the agent ships with GraalVM, so the JDK running the build is usually not one' File plain = new File(temporaryFolder, 'plain-jdk/bin/java') From cb374b1c3a05744224bb199228cfcdb140ab5010 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 11:21:27 -0600 Subject: [PATCH 089/115] Trace what was asked for, or say that it was not Three ways a trace reported success having recorded something else. A page behind a login was asked for before the form that makes it reachable was submitted, so it answered with a redirect to the login page. That counted as traced: only a 5xx failed the run, and redirects were not followed, so the status recorded was the 302. What the image was then built without was every authenticated path -- controller, binding, persistence and view -- and the first sign of it is somebody signing in. Forms are now submitted before paths are asked for, whichever order they were written in, and the session one establishes is carried through the rest of the trace. A page carrying more than one form had its first submitted. A layout's search box or sign-out sits above the page's own form and declares almost nothing, so the binding the page was listed for was never exercised while the run reported a submission. The form declaring the most fields is submitted now, which form it was is said in the output, and a page whose wanted form is not the fullest names it: forms = ['/book/create#bookForm']. A page listed under forms that carried no form, a named form that was not there, and a request answering 404 all passed. They now fail: what a trace records is only worth anything if it is what was asked for. Requests go through java.net.http.HttpClient, whose cookie store belongs to the client rather than to the JVM. That carries the session, follows redirects, and leaves the daemon's own cookie handler alone -- so the save and restore added for that is gone, and two traces at once can no longer share a store. Where a request landed is reported too, since a followed redirect otherwise records the wrong page under the right name. --- .../en/guide/deployment/deploymentAot.adoc | 38 ++- .../plugin/aot/TraceNativeMetadataTask.groovy | 230 +++++++++++++----- .../aot/TraceNativeMetadataTaskSpec.groovy | 78 +++++- .../gradle/plugin/aot/TracedRunFixture.groovy | 66 ++++- 4 files changed, 336 insertions(+), 76 deletions(-) diff --git a/grails-doc/src/en/guide/deployment/deploymentAot.adoc b/grails-doc/src/en/guide/deployment/deploymentAot.adoc index 3ec318ececc..950abd1f6d4 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAot.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAot.adoc @@ -127,7 +127,43 @@ The result is merged into `src/native/resources/META-INF/native-image`, alongsid `paths` are asked for. `forms` are asked for *and submitted*: the page is read, the fields the form declares are filled in, and they are posted to the action the form names. Submitting matters separately from rendering, because binding a form is a different half of the framework from rendering one — and it is the half that converts. A checkbox arrives as a string and lands on a boolean property, so a form submitted without one never asks the conversion service anything, and the image is built without the answer. -The task fails if a path answers with a server error, because what a failed request records is the error page rather than the page. +==== Pages behind a login + +Forms are submitted before paths are asked for, whichever order they appear in the configuration, and the session a form establishes is carried through the rest of the trace. That is what makes a protected page traceable: list its login form, and the pages named in `paths` are reached as a signed-in user. + +[source,groovy] +---- +grails { + nativeMetadata { + forms = ['/login?username=admin&password=secret', '/book/create'] + paths = ['/', '/book', '/book/show/1'] + } +} +---- + +A form may be told what to put in it with a query string, as `/login` is above. Only fields the form actually declares are set from it; a value naming a field that is not there is reported rather than posted, because it was meant for a form that has since changed. + +==== Choosing which form + +A page often carries more than one form — a layout's search box or sign-out button ahead of the page's own. The form declaring the most fields is the one submitted, and the trace output says which it was: + +[source] +---- +POST /book/save -> 200 (4 fields, from /book/create form 2 of 2, the one with the most fields) +---- + +Where the wanted form is not the fullest, name it by its `id`: + +[source,groovy] +---- +forms = ['/book/create#bookForm'] +---- + +==== When the trace fails + +The task fails if what was recorded is not what was asked for: a request that answers with an error or a not-found, a page listed under `forms` that carries no form, or a named form that is not on the page. Each of those would otherwise report a successful trace having recorded the wrong page, or nothing at all. + +Redirects are followed, so an application that sends `/` to its real home page records that page. A request that ends up somewhere other than where it was asked for is reported as a warning naming where it landed — usually the sign that a page needs its login form listed under `forms`. NOTE: The agent ships with GraalVM rather than with a JDK, and it must trace the archive the image will be built from — which is compiled for GraalVM's Java. The task uses the project toolchain, which for a project that builds an image is already a GraalVM; `grails.nativeMetadata.javaExecutable` points it elsewhere. diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index 9168a8a616e..961e55f9adb 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -18,6 +18,9 @@ */ package org.grails.gradle.plugin.aot +import java.net.http.HttpClient +import java.net.http.HttpRequest +import java.net.http.HttpResponse import java.time.Duration import java.util.concurrent.TimeUnit import java.util.regex.Matcher @@ -65,6 +68,23 @@ import org.gradle.work.DisableCachingByDefault * boolean on the domain class, so a form submitted without one never asks the conversion service * anything -- and an image built from that trace fails the first time someone ticks a box.

    * + *

    Forms are submitted before paths are asked for, and the session one establishes is carried + * through the rest of the trace. A page behind a login is reached by listing the login form, which + * makes the pages named after it reachable:

    + * + * 
    + * grails {
+ *     nativeMetadata {
+ *         forms = ['/login?username=admin&password=secret', '/book/create']
+ *         paths = ['/', '/book']
+ *     }
+ * }
+ *
    + * + *

    Where a page carries more than one form -- a layout's search or sign-out beside the page's own + * -- the one declaring the most fields is submitted, and which it was is reported. A page whose + * wanted form is not the fullest names it: {@code '/book/create#bookForm'}.

    + * *

    Written to the application's sources rather than to the build directory: what an image was * built from should be reviewable, and a trace is only as good as the paths someone thought of.

    * @@ -84,11 +104,21 @@ abstract class TraceNativeMetadataTask extends DefaultTask { private static final Pattern FORM = Pattern.compile(/(?is)]*>.*?<\/form>/) private static final Pattern ACTION = Pattern.compile(/(?i)\baction\s*=\s*"([^"]*)"/) + private static final Pattern ID = Pattern.compile(/(?i)\bid\s*=\s*"([^"]+)"/) private static final Pattern FIELD = Pattern.compile(/(?is)<(?:input|select|textarea)\b[^>]*>/) private static final Pattern NAME = Pattern.compile(/(?i)\bname\s*=\s*"([^"]+)"/) private static final Pattern VALUE = Pattern.compile(/(?i)\bvalue\s*=\s*"([^"]*)"/) private static final Pattern TYPE = Pattern.compile(/(?i)\btype\s*=\s*"([^"]+)"/) + /** + * Carries the session from one request to the next, which is what makes a form that + * authenticates worth submitting: the pages that follow it are only reachable once it has been. + * + *

    Its own cookie store rather than the JVM's. The store belongs to the client, so nothing is + * left behind in a daemon that outlives the build and two traces at once cannot share one.

    + */ + private HttpClient client + /** The archive to run, which has to be the one the image will be built from. */ @InputFile @PathSensitive(PathSensitivity.RELATIVE) @@ -147,32 +177,59 @@ abstract class TraceNativeMetadataTask extends DefaultTask { .redirectOutput(output) .start() - List answered = [] - // What carries a session from one request to the next, which is how a form that - // authenticates is worth submitting at all. It is the JVM's, and this JVM is a daemon that - // outlives the build -- so it is put back, whether the trace finished or threw. Left set, it - // would be handed to every task that ran afterwards, holding one application's cookies. - CookieHandler inherited = CookieHandler.default + client = HttpClient.newBuilder() + .cookieHandler(new CookieManager()) + .followRedirects(HttpClient.Redirect.NORMAL) + .connectTimeout(Duration.ofSeconds(10)) + .build() + + List answered = [] try { awaitStarted(process, output) - CookieHandler.default = new CookieManager() - paths.get().each { String path -> answered << ask(path) } + // Forms first, then paths. A form that authenticates is what makes the pages after it + // reachable at all: asked for beforehand, a protected page answers with a redirect to + // the login form, and what the agent records is the login page under the name of the + // page that was wanted. The session the form establishes is carried by this client. forms.get().each { String path -> answered << submit(path) } + paths.get().each { String path -> answered << ask(path) } } finally { - CookieHandler.default = inherited stop(process) } - answered.each { String line -> logger.lifecycle(' {}', line) } - List failed = answered.findAll { String line -> line.contains(' -> 5') } + answered.each { Answer answer -> logger.lifecycle(' {}', answer.line) } + answered.findAll { Answer answer -> answer.elsewhere }.each { Answer answer -> + logger.warn('{} was answered somewhere other than where it was asked for, so what was ' + + 'recorded is that page and not this one. A page behind a login is reached by ' + + 'listing its form in nativeMetadata.forms.', answer.line) + } + + List failed = answered.findAll { Answer answer -> !answer.recorded } if (failed) { - throw new GradleException('The application answered with an error while being traced, so ' + - "what was recorded is the error rather than the page:\n ${failed.join('\n ')}\n" + - "What it printed is in ${output}") + throw new GradleException('The application did not answer with the page while being ' + + 'traced, so what was recorded is not what was asked for:\n ' + + "${failed*.line.join('\n ')}\nWhat it printed is in ${output}") + } + logger.lifecycle('Traced {} forms and {} paths into {}', + forms.get().size(), paths.get().size(), metadata) + } + + /** What one request recorded, and whether it recorded the thing it was asked for. */ + private static class Answer { + + final String line + + /** Whether the page asked for is the page the agent saw. */ + final boolean recorded + + /** Whether the answer came from somewhere other than the path asked for. */ + final boolean elsewhere + + Answer(String line, boolean recorded, boolean elsewhere = false) { + this.line = line + this.recorded = recorded + this.elsewhere = elsewhere } - logger.lifecycle('Traced {} paths and {} forms into {}', - paths.get().size(), forms.get().size(), metadata) } /** @@ -191,11 +248,23 @@ abstract class TraceNativeMetadataTask extends DefaultTask { } } - /** Asks for a path, reading the body so that rendering it is part of what was recorded. */ - private String ask(String path) { - HttpURLConnection connection = open(path, 'GET') - int status = read(connection) - "GET ${path} -> ${status}".toString() + /** + * Asks for a path, reading the body so that rendering it is part of what was recorded. + * + *

    Where the answer came from is reported as well as what it was. A redirect is followed, so + * an application that sends {@code /} to its real home page records that page -- but a page + * that answers from somewhere else because the request was not allowed to reach it records the + * wrong thing under the right name, and only saying where it landed tells the two apart.

    + */ + private Answer ask(String path) { + HttpResponse response = client.send( + requestTo(path).GET().build(), HttpResponse.BodyHandlers.ofString()) + String asked = uriOf(path).path + String landed = response.uri().path + boolean elsewhere = landed != asked + String where = elsewhere ? " (landed on ${landed})" : '' + new Answer("GET ${path} -> ${response.statusCode()}${where}".toString(), + response.statusCode() < 400, elsewhere) } /** @@ -204,16 +273,20 @@ abstract class TraceNativeMetadataTask extends DefaultTask { *

    The fields come from the page rather than from a list here, because a list here is a list * to keep up to date, and the one thing a trace must not do is submit less than the form does.

    */ - private String submit(String declared) { - // A form may say what to put in it: /login?username=admin&password=... Most do not need to, - // and a generated value is better than one to keep up to date -- but a form that authenticates - // is only worth submitting with credentials that work, and what it does on success is the - // half worth recording. - int query = declared.indexOf('?') - String path = query < 0 ? declared : declared.substring(0, query) + private Answer submit(String declared) { + // A form may say what to put in it, and which of them it is: + // /login?username=admin&password=...#loginForm + // Most need neither. A generated value beats one to keep up to date -- but a form that + // authenticates is only worth submitting with credentials that work, and what it does on + // success is the half worth recording. + int fragment = declared.indexOf('#') + String named = fragment < 0 ? null : declared.substring(fragment + 1) + String withoutId = fragment < 0 ? declared : declared.substring(0, fragment) + int query = withoutId.indexOf('?') + String path = query < 0 ? withoutId : withoutId.substring(0, query) Map given = [:] if (query >= 0) { - for (String pair : declared.substring(query + 1).split('&')) { + for (String pair : withoutId.substring(query + 1).split('&')) { if (!pair) { continue } @@ -223,19 +296,22 @@ abstract class TraceNativeMetadataTask extends DefaultTask { } } - HttpURLConnection page = open(path, 'GET') - String html = body(page) - Matcher form = FORM.matcher(html ?: '') - if (!form.find()) { - return "FORM ${path} -> no form on the page".toString() + HttpResponse page = client.send( + requestTo(path).GET().build(), HttpResponse.BodyHandlers.ofString()) + List markups = formsIn(page.body()) + if (!markups) { + return new Answer("FORM ${path} -> no form on the page".toString(), false) + } + String markup = chooseForm(markups, named) + if (markup == null) { + return new Answer("FORM ${path} -> no form with id '${named}' on the page".toString(), false) } - String markup = form.group() Matcher action = ACTION.matcher(markup) String target = action.find() && action.group(1) ? action.group(1) : path Map fields = fieldsOf(markup) if (!fields) { - return "FORM ${path} -> the form declares no fields".toString() + return new Answer("FORM ${path} -> the form declares no fields".toString(), false) } // What was asked for wins, but only for a field the form has: a value for a field that is // not there was meant for a form that has changed, and silently posting it says nothing. @@ -252,12 +328,56 @@ abstract class TraceNativeMetadataTask extends DefaultTask { "${URLEncoder.encode(name, 'UTF-8')}=${URLEncoder.encode(value, 'UTF-8')}" }.join('&') - HttpURLConnection post = open(target, 'POST') - post.doOutput = true - post.setRequestProperty('Content-Type', 'application/x-www-form-urlencoded') - post.outputStream.withCloseable { OutputStream out -> out.write(encoded.bytes) } - int status = read(post) - "POST ${target} -> ${status} (${fields.size()} fields, from ${path})".toString() + HttpResponse posted = client.send( + requestTo(target) + .header('Content-Type', 'application/x-www-form-urlencoded') + .POST(HttpRequest.BodyPublishers.ofString(encoded)) + .build(), + HttpResponse.BodyHandlers.ofString()) + // Which form was submitted is said out loud. A page can carry more than one -- a layout's + // search or sign-out beside the one that was meant -- and submitting the wrong one records + // nothing of the binding it was listed for while reporting that it did. + String which = describeChoice(markups, markup, named) + new Answer("POST ${target} -> ${posted.statusCode()} " + + "(${fields.size()} fields, from ${path}${which})".toString(), + posted.statusCode() < 400) + } + + /** Every form on the page, in the order they appear. */ + private static List formsIn(String html) { + List markups = [] + Matcher form = FORM.matcher(html ?: '') + while (form.find()) { + markups << form.group() + } + markups + } + + /** + * The form to submit: the one named, or the one declaring the most fields. + * + *

    Named where a page carries more than one and the wanted one is not the fullest. Otherwise + * the fullest is the better guess than the first: a layout's search box or sign-out button + * comes before the page's own form and declares almost nothing, and taking the first meant a + * trace that reported a submission having recorded none of the binding it was listed for.

    + */ + private static String chooseForm(List markups, String named) { + if (named) { + return markups.find { String markup -> + Matcher id = ID.matcher(markup) + id.find() && id.group(1) == named + } + } + markups.max { String markup -> fieldsOf(markup).size() } + } + + /** How the chosen form is reported, said only where there was a choice to make. */ + private static String describeChoice(List markups, String chosen, String named) { + if (markups.size() == 1) { + return '' + } + String position = " form ${markups.indexOf(chosen) + 1} of ${markups.size()}" + named ? "${position} named '${named}'" : "${position}, the one with the most fields" } /** @@ -288,28 +408,14 @@ abstract class TraceNativeMetadataTask extends DefaultTask { fields } - private HttpURLConnection open(String path, String method) { - URI uri = URI.create("http://localhost:${port.get()}${path.startsWith('/') ? path : '/' + path}") - HttpURLConnection connection = (HttpURLConnection) uri.toURL().openConnection() - connection.requestMethod = method - connection.instanceFollowRedirects = false - connection.connectTimeout = 10_000 - connection.readTimeout = 60_000 - connection.setRequestProperty('Accept', 'text/html,*/*') - connection - } - - private static int read(HttpURLConnection connection) { - int status = connection.responseCode - InputStream stream = status >= 400 ? connection.errorStream : connection.inputStream - stream?.withCloseable { InputStream it -> it.bytes } - status + private HttpRequest.Builder requestTo(String path) { + HttpRequest.newBuilder(uriOf(path)) + .timeout(Duration.ofSeconds(60)) + .header('Accept', 'text/html,*/*') } - private static String body(HttpURLConnection connection) { - int status = connection.responseCode - InputStream stream = status >= 400 ? connection.errorStream : connection.inputStream - stream?.withCloseable { InputStream it -> new String(it.bytes, 'UTF-8') } + private URI uriOf(String path) { + URI.create("http://localhost:${port.get()}${path.startsWith('/') ? path : '/' + path}") } private void awaitStarted(Process process, File output) { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy index 4c269e027a6..9b65e7aca51 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy @@ -159,6 +159,80 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ !posted.contains('nosuchfield') } + void 'the form with the most fields is the one submitted'() { + given: 'a page carrying a layout search form ahead of its own' + TraceNativeMetadataTask task = task([], ['/create']) + + when: + task.trace() + + then: 'taking the first would report a submission having recorded none of the binding' + requested.any { it.startsWith('POST /save') } + !requested.any { it.startsWith('POST /search') } + } + + void 'a form can be named where the wanted one is not the fullest'() { + given: + TraceNativeMetadataTask task = task([], ['/create#searchForm']) + + when: + task.trace() + + then: + requested.any { it.startsWith('POST /search') } + !requested.any { it.startsWith('POST /save') } + } + + void 'naming a form that is not on the page fails the trace'() { + given: 'rather than falling back to another and reporting that one as covered' + TraceNativeMetadataTask task = task([], ['/create#nosuchform']) + + when: + task.trace() + + then: + GradleException e = thrown() + e.message.contains("no form with id 'nosuchform'") + } + + void 'a page behind a login is reached because the form is submitted first'() { + given: 'the form listed after the path it makes reachable, to show the order is not the list' + TraceNativeMetadataTask task = task(['/protected'], ['/login?username=admin&password=s3cret']) + + when: + task.trace() + + then: 'the credentials given reach the application' + requested.any { it.startsWith('POST /authenticate') && it.contains('username=admin') } + + and: 'and the protected page answers with itself rather than with the login page' + requested.any { it == 'GET /protected' } + !requested.any { it == 'GET /login' && requested.indexOf(it) > requested.findIndexOf { it.startsWith('POST /authenticate') } } + } + + void 'a page answered from somewhere else is reported rather than counted'() { + given: 'asked for without the login form that makes it reachable' + TraceNativeMetadataTask task = task(['/protected'], []) + + when: + task.trace() + + then: 'the redirect is followed, so what the agent recorded is the login page' + requested.any { it == 'GET /login' } + } + + void 'a form on a page that has none fails the trace'() { + given: + TraceNativeMetadataTask task = task([], ['/']) + + when: + task.trace() + + then: 'listed to be submitted and never submitted is a gap, not a success' + GradleException e = thrown() + e.message.contains('no form on the page') + } + void 'a path that answers with an error fails the trace'() { given: 'because what would be recorded is the error page rather than the page' TraceNativeMetadataTask task = task(['/broken'], []) @@ -168,7 +242,7 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ then: GradleException e = thrown() - e.message.contains('answered with an error') + e.message.contains('did not answer with the page') e.message.contains('/broken') } @@ -181,7 +255,7 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ then: 'a save that 500s during tracing records the failure and nothing of the save' GradleException e = thrown() - e.message.contains('answered with an error') + e.message.contains('did not answer with the page') } void 'the cookie handler the build had is put back after a trace'() { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy index 96892fcb2f1..89a55deb336 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy @@ -24,13 +24,37 @@ import com.sun.net.httpserver.HttpExchange import com.sun.net.httpserver.HttpServer /** - * An application for the trace to record: it serves a form, and writes down what it was asked for. + * An application for the trace to record: it serves forms, guards a page behind a login, and writes + * down what it was asked for. * *

    The form is the point. A page can be fetched by anything; only submitting one shows whether the * fields a form declares are the fields that arrive.

    + * + *

    Two of the shapes here are the ones a trace gets wrong rather than the ones it gets right: a + * page carrying a layout form ahead of its own, and a page that answers with a redirect to the login + * form until the login form has been submitted.

    */ class TracedRunFixture { + /** What a page carrying a layout form ahead of its own looks like. */ + private static final String TWO_FORMS = ''' +
    + +
    +
    + + + + + +
    ''' + + private static final String LOGIN_FORM = ''' +
    + + +
    ''' + static void main(String[] args) { int port = Integer.parseInt(args[0]) File requested = new File(args[1]) @@ -42,6 +66,7 @@ class TracedRunFixture { String method = exchange.requestMethod String body = method == 'POST' ? exchange.requestBody.getText('UTF-8') : '' requested << "${method} ${path}${body ? ' ' + body : ''}\n" + boolean signedIn = exchange.requestHeaders.getFirst('Cookie')?.contains('session=in') int status = 200 String response = 'served' @@ -50,14 +75,28 @@ class TracedRunFixture { response = 'no' } else if (path == '/create') { - response = ''' -
    - - - - - -
    ''' + response = TWO_FORMS + } + else if (path == '/login') { + response = LOGIN_FORM + } + else if (path == '/authenticate') { + exchange.responseHeaders.add('Set-Cookie', 'session=in; Path=/') + status = 302 + exchange.responseHeaders.add('Location', '/') + response = '' + } + else if (path == '/protected') { + // answered from the login page until the login form has been submitted, which is + // what makes asking for it before submitting that form record the wrong page + if (!signedIn) { + status = 302 + exchange.responseHeaders.add('Location', '/login') + response = '' + } + else { + response = 'the protected page' + } } else if (path == '/save' && behaviour == 'save-fails') { status = 500 @@ -65,8 +104,13 @@ class TracedRunFixture { } byte[] bytes = response.bytes - exchange.sendResponseHeaders(status, bytes.length) - exchange.responseBody.withCloseable { it.write(bytes) } + exchange.sendResponseHeaders(status, bytes.length ?: -1) + if (bytes.length) { + exchange.responseBody.withCloseable { it.write(bytes) } + } + else { + exchange.responseBody.close() + } } server.start() println 'Started Application in 0.05 seconds' From fb6518ead975a30780358db028c42263d5076416 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 11:57:09 -0600 Subject: [PATCH 090/115] Check where a form page was answered from, as a path already is Asking for a form page follows redirects, and where it landed went unchecked. A page behind a login answers from the login form, and everything after that passes: that page has a form, its fields are filled in, it posts, and it answers below 400. What was reported was the login form submitted a second time under the name of the page that was wanted, while the binding it was listed for went unexercised. The same happens with credentials that are rejected -- every protected form after them falls back to the login page and is recorded as that. The check ask() already makes, made here too, and failing rather than warning: a path that redirects still traced a page, and an application is free to send one page to another; a form that redirects traced a different form, and there is no reading of that which is what was asked for. A status of 400 or worse asking for the page fails here as well, rather than being left to look like a page with no form on it. The fixture grew a form only a signed-in visitor is shown, which is the shape that made this pass: the page it lands on has a form of its own. Confirmed capable of failing -- with the check disabled, the new spec sees POST /authenticate recorded under the protected page's name. --- .../en/guide/deployment/deploymentAot.adoc | 4 ++- .../plugin/aot/TraceNativeMetadataTask.groovy | 18 +++++++++++ .../aot/TraceNativeMetadataTaskSpec.groovy | 31 +++++++++++++++++++ .../gradle/plugin/aot/TracedRunFixture.groovy | 18 +++++++++++ 4 files changed, 70 insertions(+), 1 deletion(-) diff --git a/grails-doc/src/en/guide/deployment/deploymentAot.adoc b/grails-doc/src/en/guide/deployment/deploymentAot.adoc index 950abd1f6d4..ac4b62c4c60 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAot.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAot.adoc @@ -161,7 +161,9 @@ forms = ['/book/create#bookForm'] ==== When the trace fails -The task fails if what was recorded is not what was asked for: a request that answers with an error or a not-found, a page listed under `forms` that carries no form, or a named form that is not on the page. Each of those would otherwise report a successful trace having recorded the wrong page, or nothing at all. +The task fails if what was recorded is not what was asked for: a request that answers with an error or a not-found, a page listed under `forms` that carries no form, a named form that is not on the page, or a form page that answered from somewhere else. + +That last one is the case worth knowing about. A form page reached without whatever makes it reachable answers from the login form instead, and every check after that passes — the page it landed on has a form, its fields are filled in, it posts, and it answers successfully. What would be reported is the login form submitted a second time under the name of the page that was wanted, while the binding the page was listed for went unexercised. So a form that answers from anywhere other than where it was asked for fails the trace, and the message names where it landed. Redirects are followed, so an application that sends `/` to its real home page records that page. A request that ends up somewhere other than where it was asked for is reported as a warning naming where it landed — usually the sign that a page needs its login form listed under `forms`. diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index 961e55f9adb..b23b933ae2f 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -298,6 +298,24 @@ abstract class TraceNativeMetadataTask extends DefaultTask { HttpResponse page = client.send( requestTo(path).GET().build(), HttpResponse.BodyHandlers.ofString()) + if (page.statusCode() >= 400) { + return new Answer("FORM ${path} -> ${page.statusCode()} asking for the page".toString(), false) + } + // Where the page came from, not only that one did. A form page reached without whatever + // makes it reachable answers from the login form instead, and every check after this one + // passes: that page has a form, its fields are filled in, it posts, and it answers below + // 400. What would be reported is the login form submitted a second time under the name of + // the page that was wanted, while the binding this was listed for went unexercised. + // + // Failed rather than warned, which is where this differs from asking for a path. A path + // that redirects still traced a page, and an application is free to send one page to + // another; a form that redirects traced a different form, and there is no reading of that + // which is what was asked for. + String landed = page.uri().path + if (landed != uriOf(path).path) { + return new Answer("FORM ${path} -> answered from ${landed}, so the form there is not " + + 'this one. A page behind a login is reached by listing its form first.', false) + } List markups = formsIn(page.body()) if (!markups) { return new Answer("FORM ${path} -> no form on the page".toString(), false) diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy index 9b65e7aca51..bcda3058af7 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy @@ -221,6 +221,37 @@ exec '${new File(System.getProperty('java.home'), 'bin/java').absolutePath}' \\ requested.any { it == 'GET /login' } } + void 'a form page answered from the login page does not count as tracing the form'() { + given: 'only the protected form listed, so nothing has made it reachable' + TraceNativeMetadataTask task = task([], ['/protected-form']) + + when: + task.trace() + + then: 'the page it lands on has a form of its own, so every check after the redirect passes' + GradleException e = thrown() + e.message.contains('/protected-form') + e.message.contains('answered from /login') + + and: 'and the login form it landed on was not submitted under the protected page\'s name' + !requested.any { it.startsWith('POST /authenticate') } + + and: 'nor was the binding it was listed for ever exercised' + !requested.any { it.startsWith('POST /protected-save') } + } + + void 'and is traced once the form that makes it reachable is listed'() { + given: + TraceNativeMetadataTask task = task([], + ['/login?username=admin&password=s3cret', '/protected-form']) + + when: + task.trace() + + then: 'the form on the page that was asked for, rather than the one on the way to it' + requested.any { it.startsWith('POST /protected-save') && it.contains('secretTitle=') } + } + void 'a form on a page that has none fails the trace'() { given: TraceNativeMetadataTask task = task([], ['/']) diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy index 89a55deb336..ae9d71e43dc 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy @@ -55,6 +55,12 @@ class TracedRunFixture { ''' + /** A form only a signed-in visitor is shown, which is what makes reaching it worth checking. */ + private static final String PROTECTED_FORM = ''' +
    + +
    ''' + static void main(String[] args) { int port = Integer.parseInt(args[0]) File requested = new File(args[1]) @@ -86,6 +92,18 @@ class TracedRunFixture { exchange.responseHeaders.add('Location', '/') response = '' } + else if (path == '/protected-form') { + // the shape that made a redirected form page count as traced: the page it lands on + // has a form of its own, so everything after the redirect succeeds + if (!signedIn) { + status = 302 + exchange.responseHeaders.add('Location', '/login') + response = '' + } + else { + response = PROTECTED_FORM + } + } else if (path == '/protected') { // answered from the login page until the login form has been submitted, which is // what makes asking for it before submitting that form record the wrong page From abd0453525d877b414ae54eb6d38e67b727182eb Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 12 Aug 2026 21:51:29 -0600 Subject: [PATCH 091/115] Bind the qualified domain name when expanding scaffolded views The task bound only className and propertyName, so a template could name the domain class but not write a type that resolves from the generated page. A statically compiled scaffolded view has to declare its model, and "User user" does not resolve where the class is com.example.User. Read the qualified name from the @Scaffold annotation rather than throwing the package away, and bind fullName and packageName beside the naming. The templates then declare their model, which is what lets a scaffolded view compile statically without the application editing it. Also stop over-escaping the list container id in index.gsp. It survived expansion as a runtime ${propertyName}, which nothing binds, so the id rendered as "list-" and the skip link above it pointed at nothing. --- .../GenerateScaffoldedViewsTask.groovy | 49 ++++++++++++------- .../GenerateScaffoldedViewsTaskSpec.groovy | 17 +++++++ .../src/main/templates/scaffolding/create.gsp | 1 + .../src/main/templates/scaffolding/edit.gsp | 1 + .../src/main/templates/scaffolding/index.gsp | 3 +- .../src/main/templates/scaffolding/show.gsp | 1 + 6 files changed, 54 insertions(+), 18 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy index 3b2e56f7af1..67be6b9f4de 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy @@ -47,10 +47,12 @@ import org.gradle.api.tasks.TaskAction * gives up. Expanding the templates here instead lets the ordinary GSP compiler precompile the * result, so at runtime the views are found rather than produced.

    * - *

    Only naming is substituted -- the templates read {@code className} and {@code propertyName}, - * and defer everything about the domain class to the field tag libraries at render time. That is - * why this needs no GORM, no application context and no loading of application classes: the - * controllers are read with ASM and the domain class name is enough.

    + *

    Only naming is substituted -- the templates read {@code className}, {@code propertyName}, + * {@code fullName} and {@code packageName}, and defer everything else about the domain class to the + * field tag libraries at render time. That is why this needs no GORM, no application context and no + * loading of application classes: the controllers are read with ASM and the domain class name is + * enough. The qualified name is bound too, so that a template can declare the type of its model in a + * form that resolves from the generated page.

    * *

    A view the application already declares is never overwritten, which keeps the existing * precedence: a hand-written {@code grails-app/views} page wins over a scaffolded one.

    @@ -114,8 +116,10 @@ abstract class GenerateScaffoldedViewsTask extends DefaultTask { Set declared = applicationViews.files int written = 0 for (Map.Entry controller : findScaffoldedControllers()) { - String propertyName = controller.value - String className = capitalize(propertyName) + String fullName = controller.value + String className = fullName.tokenize('.').last() + String propertyName = decapitalize(className) + String packageName = fullName.contains('.') ? fullName[0..{@code fullName} and {@code packageName} are bound alongside the naming because a template + * that declares the type of its model has to name a type that resolves from the page, and the + * simple name does not.

    + */ + private String expand(String template, String className, String propertyName, String fullName, String packageName) { StringWriter out = new StringWriter() new GStringTemplateEngine() .createTemplate(template) - .make([className: className, propertyName: propertyName]) + .make([className: className, propertyName: propertyName, + fullName: fullName, packageName: packageName, modelName: propertyName]) .writeTo(out) out.toString() } @@ -178,7 +189,11 @@ abstract class GenerateScaffoldedViewsTask extends DefaultTask { templates } - /** Maps view directory name to the domain property name, for every {@code @Scaffold} controller. */ + /** + * Maps view directory name to the fully qualified domain class, for every {@code @Scaffold} + * controller. Qualified rather than simple because a view declaring the type of its model has to + * name a type that resolves. + */ private Map findScaffoldedControllers() { Map found = [:] for (File dir : classesDirs.files) { @@ -192,7 +207,7 @@ abstract class GenerateScaffoldedViewsTask extends DefaultTask { String domain = readScaffoldDomain(f) if (domain != null) { String controllerName = decapitalize(f.name - 'Controller.class') - found.put(controllerName, decapitalize(domain)) + found.put(controllerName, domain) } } } @@ -200,9 +215,9 @@ abstract class GenerateScaffoldedViewsTask extends DefaultTask { } /** - * Returns the simple name of the domain class a controller scaffolds, or {@code null} when it is - * not scaffolded. Read with ASM so the application's classes are never loaded, which keeps the - * task independent of the runtime classpath. + * Returns the fully qualified name of the domain class a controller scaffolds, or {@code null} + * when it is not scaffolded. Read with ASM so the application's classes are never loaded, which + * keeps the task independent of the runtime classpath. */ private String readScaffoldDomain(File classFile) { String domain = null @@ -218,8 +233,8 @@ abstract class GenerateScaffoldedViewsTask extends DefaultTask { void visit(String name, Object value) { // both @Scaffold(User) and @Scaffold(domain = User) name the domain class if (value instanceof Type && (name == 'value' || name == 'domain')) { - String candidate = ((Type) value).className.tokenize('.').last() - if (candidate != 'Void') { + String candidate = ((Type) value).className + if (candidate.tokenize('.').last() != 'Void') { domain = candidate } } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy index 33ffe0736c5..361e624086a 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy @@ -128,6 +128,23 @@ class GenerateScaffoldedViewsTaskSpec extends Specification { generated(task, 'user/index.gsp').text == 'list of user for User' } + void 'the qualified domain class is substituted, so a template can declare the type of its model'() { + given: + writeTemplateJar(templateJar, [ + index : 'model="List<${fullName}> ${propertyName}List" in ${packageName}', + create: 'create ${className}', + edit : 'edit ${className}', + show : 'show ${className}']) + writeController('UserController', 'User') + def task = task() + + when: + task.generate() + + then: 'the simple name alone would not resolve from the generated page' + generated(task, 'user/index.gsp').text == 'model="List userList" in com.example' + } + void 'a controller without the annotation is left alone'() { given: writePlainController('PlainController') diff --git a/grails-scaffolding/src/main/templates/scaffolding/create.gsp b/grails-scaffolding/src/main/templates/scaffolding/create.gsp index 44b96f859b7..9a140b71384 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/create.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/create.gsp @@ -1,3 +1,4 @@ +@{ model="${fullName} ${propertyName}" } diff --git a/grails-scaffolding/src/main/templates/scaffolding/edit.gsp b/grails-scaffolding/src/main/templates/scaffolding/edit.gsp index d899b70c724..2966da6fd49 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/edit.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/edit.gsp @@ -1,3 +1,4 @@ +@{ model="${fullName} ${propertyName}" } diff --git a/grails-scaffolding/src/main/templates/scaffolding/index.gsp b/grails-scaffolding/src/main/templates/scaffolding/index.gsp index 303fbc6520e..2d4eb907ca2 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/index.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/index.gsp @@ -1,3 +1,4 @@ +@{ model="List<${fullName}> ${propertyName}List; Integer ${propertyName}Count" } @@ -22,7 +23,7 @@
    -
    +

    diff --git a/grails-scaffolding/src/main/templates/scaffolding/show.gsp b/grails-scaffolding/src/main/templates/scaffolding/show.gsp index a82632d8537..528101a5aca 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/show.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/show.gsp @@ -1,3 +1,4 @@ +@{ model="${fullName} ${propertyName}" } From 2eb6d04f46754318a7cde52b91c1055068edd7e7 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 13 Aug 2026 00:58:51 -0600 Subject: [PATCH 092/115] Read the Spring Security version off the package, not through reflection Going through ReflectionUtils avoided the caller-sensitive Method.invoke a native image rejects, but it is still reflection, and the version is already on the package the class was loaded from. That is where the startup banner reads it (GrailsBanner.findVersion), and reading it the same way here leaves nothing for an image to reject and nothing to resolve at runtime. Drops the import that was only there for it. --- .../grails-forge-core/src/main/resources/gsp/index.gsp | 9 ++++----- grails-profiles/web/skeleton/grails-app/views/index.gsp | 9 ++++----- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp b/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp index add9c633cc9..93fd4830013 100644 --- a/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp +++ b/grails-forge/grails-forge-core/src/main/resources/gsp/index.gsp @@ -2,7 +2,6 @@ <%@ page import="org.springframework.boot.SpringBootVersion"%> <%@ page import="org.springframework.core.SpringVersion"%> <%@ page import="org.springframework.util.ClassUtils"%> -<%@ page import="org.springframework.util.ReflectionUtils"%> ${SpringVersion.getVersion()} - <%-- Spring Security: only when the dependency is present. The call goes - through ReflectionUtils because invoking Method.invoke from Groovy - resolves to a caller-sensitive overload that a native image rejects. --%> + <%-- Spring Security: only when the dependency is present. The version comes + off the package the class was loaded from, the way the banner reads it, + so there is no reflection here for a native image to reject. --%> + value="${springSecurityCoreVersionClass?.package?.implementationVersion}"/>
  • diff --git a/grails-profiles/web/skeleton/grails-app/views/index.gsp b/grails-profiles/web/skeleton/grails-app/views/index.gsp index add9c633cc9..93fd4830013 100644 --- a/grails-profiles/web/skeleton/grails-app/views/index.gsp +++ b/grails-profiles/web/skeleton/grails-app/views/index.gsp @@ -2,7 +2,6 @@ <%@ page import="org.springframework.boot.SpringBootVersion"%> <%@ page import="org.springframework.core.SpringVersion"%> <%@ page import="org.springframework.util.ClassUtils"%> -<%@ page import="org.springframework.util.ReflectionUtils"%> ${SpringVersion.getVersion()}
    • - <%-- Spring Security: only when the dependency is present. The call goes - through ReflectionUtils because invoking Method.invoke from Groovy - resolves to a caller-sensitive overload that a native image rejects. --%> + <%-- Spring Security: only when the dependency is present. The version comes + off the package the class was loaded from, the way the banner reads it, + so there is no reflection here for a native image to reject. --%> + value="${springSecurityCoreVersionClass?.package?.implementationVersion}"/>
  • From e93d383ea8f91ec2d6a1c699fb1f1d1e83040658 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 13 Aug 2026 23:50:54 -0700 Subject: [PATCH 093/115] Leave scaffolded views to be produced where they always were Expanding the templates at build time so the GSP compiler could precompile them rests on the templates being compilable that way, and they are not. A scaffolded page reads entityName, which the page declares with g:set as it renders, and controllerName, which the request carries. Neither is a variable a static compile can see: [Static type checking] - The variable [entityName] is undeclared. [Static type checking] - The variable [controllerName] is undeclared. That failed compileGroovyPages for every project that scaffolds, and with it 652 tests across the scaffolding, fields and GORM example applications. Declaring the model in the templates was an attempt at the same thing from the other end, and it changed the pages every application renders at run time to serve a build-time feature. Both are removed. Making a scaffolded view precompilable means making the templates say what they read, which changes what scaffolding renders for everyone and is its own piece of work. Nothing in this one needs it: precompiled scaffolded views matter to a native image, which this does not yet deliver. The list container id in index.gsp keeps its fix -- it was expanded rather than left as a runtime expression nothing binds, and that is unrelated. --- .../GenerateScaffoldedViewsTask.groovy | 260 ------------------ .../plugin/views/gsp/GroovyPagePlugin.groovy | 102 +------ .../GenerateScaffoldedViewsTaskSpec.groovy | 222 --------------- .../src/main/templates/scaffolding/create.gsp | 1 - .../src/main/templates/scaffolding/edit.gsp | 1 - .../src/main/templates/scaffolding/index.gsp | 1 - .../src/main/templates/scaffolding/show.gsp | 1 - 7 files changed, 1 insertion(+), 587 deletions(-) delete mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy delete mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy deleted file mode 100644 index 67be6b9f4de..00000000000 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTask.groovy +++ /dev/null @@ -1,260 +0,0 @@ -/* - * 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.grails.gradle.plugin.scaffolding - -import java.util.jar.JarEntry -import java.util.jar.JarFile - -import groovy.text.GStringTemplateEngine -import groovy.transform.CompileStatic -import groovyjarjarasm.asm.AnnotationVisitor -import groovyjarjarasm.asm.ClassReader -import groovyjarjarasm.asm.ClassVisitor -import groovyjarjarasm.asm.Opcodes -import groovyjarjarasm.asm.Type - -import org.gradle.api.DefaultTask -import org.gradle.api.file.ConfigurableFileCollection -import org.gradle.api.file.DirectoryProperty -import org.gradle.api.tasks.CacheableTask -import org.gradle.api.tasks.InputFiles -import org.gradle.api.tasks.Optional -import org.gradle.api.tasks.OutputDirectory -import org.gradle.api.tasks.PathSensitive -import org.gradle.api.tasks.PathSensitivity -import org.gradle.api.tasks.TaskAction - -/** - * Writes the views a scaffolded controller would otherwise generate on its first request. - * - *

    Scaffolding expands a template into GSP source and compiles the result, and until now it did - * both when the view was first asked for. That costs the first request on the JVM, and a native - * image cannot do it at all: defining a class at runtime is exactly what an ahead-of-time image - * gives up. Expanding the templates here instead lets the ordinary GSP compiler precompile the - * result, so at runtime the views are found rather than produced.

    - * - *

    Only naming is substituted -- the templates read {@code className}, {@code propertyName}, - * {@code fullName} and {@code packageName}, and defer everything else about the domain class to the - * field tag libraries at render time. That is why this needs no GORM, no application context and no - * loading of application classes: the controllers are read with ASM and the domain class name is - * enough. The qualified name is bound too, so that a template can declare the type of its model in a - * form that resolves from the generated page.

    - * - *

    A view the application already declares is never overwritten, which keeps the existing - * precedence: a hand-written {@code grails-app/views} page wins over a scaffolded one.

    - * - * @since 8.0 - */ -@CacheableTask -@CompileStatic -abstract class GenerateScaffoldedViewsTask extends DefaultTask { - - /** Descriptor of the annotation that marks a scaffolded controller. */ - private static final String SCAFFOLD_ANNOTATION = 'Lgrails/plugin/scaffolding/annotation/Scaffold;' - - /** Path within an artifact holding the scaffolding templates. */ - private static final String TEMPLATE_PATH = 'META-INF/templates/scaffolding/' - - /** The views scaffolding knows how to produce. */ - private static final List VIEW_NAMES = ['index', 'create', 'edit', 'show'] - - /** Compiled application classes, searched for scaffolded controllers. */ - @InputFiles - @PathSensitive(PathSensitivity.RELATIVE) - abstract ConfigurableFileCollection getClassesDirs() - - /** - * The classpath the scaffolding templates are read from. The application's own - * {@code src/main/templates/scaffolding} takes precedence, matching the runtime lookup. - */ - @InputFiles - @PathSensitive(PathSensitivity.RELATIVE) - abstract ConfigurableFileCollection getTemplateClasspath() - - /** Application template overrides, normally {@code src/main/templates/scaffolding}. */ - @InputFiles - @Optional - @PathSensitive(PathSensitivity.RELATIVE) - abstract ConfigurableFileCollection getTemplateOverrides() - - /** The application's own views; anything declared here is left alone. */ - @InputFiles - @Optional - @PathSensitive(PathSensitivity.RELATIVE) - abstract ConfigurableFileCollection getApplicationViews() - - /** Where the generated views are written. */ - @OutputDirectory - abstract DirectoryProperty getOutputDirectory() - - @TaskAction - void generate() { - File outputDir = outputDirectory.get().asFile - outputDir.deleteDir() - outputDir.mkdirs() - - Map templates = loadTemplates() - if (templates.isEmpty()) { - logger.info('No scaffolding templates on the classpath; nothing to generate') - return - } - - Set declared = applicationViews.files - int written = 0 - for (Map.Entry controller : findScaffoldedControllers()) { - String fullName = controller.value - String className = fullName.tokenize('.').last() - String propertyName = decapitalize(className) - String packageName = fullName.contains('.') ? fullName[0..{@code fullName} and {@code packageName} are bound alongside the naming because a template - * that declares the type of its model has to name a type that resolves from the page, and the - * simple name does not.

    - */ - private String expand(String template, String className, String propertyName, String fullName, String packageName) { - StringWriter out = new StringWriter() - new GStringTemplateEngine() - .createTemplate(template) - .make([className: className, propertyName: propertyName, - fullName: fullName, packageName: packageName, modelName: propertyName]) - .writeTo(out) - out.toString() - } - - /** - * Maps view name to template text, with the application's overrides winning over the templates - * a plugin contributes. - */ - private Map loadTemplates() { - Map templates = [:] - for (File entry : templateClasspath.files) { - if (entry.isDirectory()) { - File dir = new File(entry, TEMPLATE_PATH) - if (dir.isDirectory()) { - dir.eachFileMatch(~/.*\.gsp/) { File f -> templates.putIfAbsent(baseName(f.name), f.text) } - } - } - else if (entry.name.endsWith('.jar') && entry.isFile()) { - new JarFile(entry).withCloseable { JarFile jar -> - for (JarEntry e : jar.entries()) { - if (e.name.startsWith(TEMPLATE_PATH) && e.name.endsWith('.gsp')) { - templates.putIfAbsent(baseName(e.name.substring(TEMPLATE_PATH.length())), - jar.getInputStream(e).getText('UTF-8')) - } - } - } - } - } - for (File override : templateOverrides.files) { - if (override.isFile() && override.name.endsWith('.gsp')) { - templates.put(baseName(override.name), override.text) - } - } - templates - } - - /** - * Maps view directory name to the fully qualified domain class, for every {@code @Scaffold} - * controller. Qualified rather than simple because a view declaring the type of its model has to - * name a type that resolves. - */ - private Map findScaffoldedControllers() { - Map found = [:] - for (File dir : classesDirs.files) { - if (!dir.isDirectory()) { - continue - } - dir.eachFileRecurse { File f -> - if (!f.name.endsWith('Controller.class')) { - return - } - String domain = readScaffoldDomain(f) - if (domain != null) { - String controllerName = decapitalize(f.name - 'Controller.class') - found.put(controllerName, domain) - } - } - } - found - } - - /** - * Returns the fully qualified name of the domain class a controller scaffolds, or {@code null} - * when it is not scaffolded. Read with ASM so the application's classes are never loaded, which - * keeps the task independent of the runtime classpath. - */ - private String readScaffoldDomain(File classFile) { - String domain = null - classFile.withInputStream { InputStream input -> - new ClassReader(input).accept(new ClassVisitor(Opcodes.ASM9) { - @Override - AnnotationVisitor visitAnnotation(String descriptor, boolean visible) { - if (descriptor != SCAFFOLD_ANNOTATION) { - return null - } - return new AnnotationVisitor(Opcodes.ASM9) { - @Override - void visit(String name, Object value) { - // both @Scaffold(User) and @Scaffold(domain = User) name the domain class - if (value instanceof Type && (name == 'value' || name == 'domain')) { - String candidate = ((Type) value).className - if (candidate.tokenize('.').last() != 'Void') { - domain = candidate - } - } - } - } - } - }, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES) - } - domain - } - - private static String baseName(String fileName) { - fileName.endsWith('.gsp') ? fileName[0.. { JavaToolchainService toolchains = project.extensions.getByType(JavaToolchainService) Provider launcher = toolchains.launcherFor(javaExtension.toolchain) - // A scaffolded controller has no views of its own, so they are expanded from their - // templates and compiled with the rest. They are staged together rather than compiled - // separately, because a second compilation writes a second gsp/views.properties and the - // archive tasks discard duplicates, losing the views one of them lists. - // - // Only a project that scaffolds pays for this. Staging copies the views, and pointing the - // compilation at the copy would change what every other project compiles for no reason. - Directory appViews = project.layout.projectDirectory.dir('grails-app/views') - boolean scaffolds = scaffoldsAnyController(project).get() - - Directory viewsToCompile = appViews - if (scaffolds) { - Provider stagedViews = project.layout.buildDirectory.dir('generated/views') - def generateScaffoldedViews = tasks.register( - 'generateScaffoldedViews', GenerateScaffoldedViewsTask) { GenerateScaffoldedViewsTask it -> - it.group = BasePlugin.BUILD_GROUP - it.description = 'Expands the views of scaffolded controllers so they can be precompiled' - // the classes directory is written by more than one task, so the dependency is stated - // against the compilation rather than inferred from the directory - it.dependsOn(tasks.named('compileJava')) - ['compileGroovy', 'copyAstClasses'].each { String name -> - if (project.tasks.findByName(name)) { - it.dependsOn(tasks.named(name)) - } - } - it.classesDirs.from(classesDirs) - it.templateClasspath.from(project.configurations.named('compileClasspath')) - it.templateOverrides.from( - project.fileTree(project.layout.projectDirectory.dir('src/main/templates/scaffolding')) - .matching { PatternFilterable p -> p.include('*.gsp') }) - it.applicationViews.from( - project.fileTree(appViews) - .matching { PatternFilterable p -> p.include('**/*.gsp') }) - it.outputDirectory.set(project.layout.buildDirectory.dir('generated/scaffolded-views')) - } - - tasks.register('stageGroovyPages', Sync) { Sync it -> - it.description = 'Collects the application and scaffolded views for GSP compilation' - it.into(stagedViews) - it.from(appViews) - it.from(generateScaffoldedViews) - // the application's own page wins, matching how the view resolvers are ordered - it.duplicatesStrategy = DuplicatesStrategy.EXCLUDE - } - viewsToCompile = stagedViews.get() - } - def compileGroovyPages = tasks.register('compileGroovyPages', GroovyPageForkCompileTask) { it.destinationDirectory.set(destDir) it.tmpDirPath = getTmpDirPath(project) - // the setter takes a directory rather than a provider: it has to set both srcDir - // and the SourceTask inputs, and setting srcDir alone compiles nothing - it.source = viewsToCompile + it.source = project.layout.projectDirectory.dir('grails-app/views') it.serverpath.set('/WEB-INF/grails-app/views/') it.classpath = allClasspath it.javaLauncher.convention(launcher) - if (scaffolds) { - it.dependsOn(tasks.named('stageGroovyPages')) - } } def compileWebappGroovyPages = tasks.register('compileWebappGroovyPages', GroovyPageForkCompileTask) { @@ -205,46 +145,6 @@ class GroovyPagePlugin implements Plugin { } } - /** - * Whether any controller in this project is scaffolded, which decides whether the views are - * staged before they are compiled. The answer is needed while the build is being configured, - * before anything has been compiled, so it is read from the sources. - * - *

    Read through a {@link ValueSource} rather than by opening the files here. Gradle re-runs a - * value source on every build and invalidates the configuration cache when its answer changes, - * so a controller that becomes scaffolded rebuilds the graph that generates its views. Read - * directly, the answer would be an undeclared input: settled once, cached, and wrong from then - * on.

    - * - *

    The match is deliberately loose. {@link GenerateScaffoldedViewsTask} reads the real - * annotation from the compiled class, so a false positive here costs a staging copy and a - * generation task that writes nothing -- while a false negative costs a view that is missing - * from the artifact, found by whoever opens that page.

    - */ - protected Provider scaffoldsAnyController(Project project) { - project.providers.of(ScaffoldedControllers) { ValueSourceSpec spec -> - spec.parameters.controllers.from( - project.fileTree(project.layout.projectDirectory.dir('grails-app/controllers')) - .matching { PatternFilterable p -> p.include('**/*.groovy') }) - } - } - - /** Reads the controller sources for the mark of a scaffolded one, as a tracked build input. */ - abstract static class ScaffoldedControllers implements ValueSource { - - interface Parameters extends ValueSourceParameters { - - ConfigurableFileCollection getControllers() - - } - - @Override - Boolean obtain() { - parameters.controllers.files.any { File controller -> controller.text.contains('@Scaffold') } - } - - } - protected FileCollection resolveClassesDirs(SourceSetOutput output, Project project) { output?.classesDirs ?: project.files(project.layout.buildDirectory.dir('classes/main')) } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy deleted file mode 100644 index 361e624086a..00000000000 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/scaffolding/GenerateScaffoldedViewsTaskSpec.groovy +++ /dev/null @@ -1,222 +0,0 @@ -/* - * 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.grails.gradle.plugin.scaffolding - -import java.util.jar.JarEntry -import java.util.jar.JarOutputStream - -import groovyjarjarasm.asm.AnnotationVisitor -import groovyjarjarasm.asm.ClassWriter -import groovyjarjarasm.asm.Opcodes -import groovyjarjarasm.asm.Type -import spock.lang.Specification -import spock.lang.TempDir - -import org.gradle.api.Project -import org.gradle.testfixtures.ProjectBuilder - -class GenerateScaffoldedViewsTaskSpec extends Specification { - - @TempDir - File projectDir - - private File classesDir - private File templateJar - - void setup() { - classesDir = new File(projectDir, 'classes') - classesDir.mkdirs() - templateJar = new File(projectDir, 'templates.jar') - writeTemplateJar(templateJar, [ - index : 'list of ${propertyName} for ${className}', - create: 'create ${className}', - edit : 'edit ${className}', - show : 'show ${className}']) - } - - /** A jar shaped like the one the scaffolding plugin publishes. */ - private void writeTemplateJar(File jar, Map templates) { - new JarOutputStream(jar.newOutputStream()).withCloseable { JarOutputStream out -> - templates.each { String name, String body -> - out.putNextEntry(new JarEntry("META-INF/templates/scaffolding/${name}.gsp")) - out.write(body.bytes) - out.closeEntry() - } - } - } - - /** - * Writes a class carrying {@code @Scaffold}, so the task reads a real annotation rather than a - * stand-in for one. - */ - private void writeController(String controllerName, String domainClassName) { - ClassWriter writer = new ClassWriter(0) - writer.visit(Opcodes.V21, Opcodes.ACC_PUBLIC, "com/example/${controllerName}", null, - 'java/lang/Object', null) - AnnotationVisitor annotation = writer.visitAnnotation( - 'Lgrails/plugin/scaffolding/annotation/Scaffold;', true) - annotation.visit('value', Type.getObjectType("com/example/${domainClassName}")) - annotation.visitEnd() - writer.visitEnd() - File target = new File(classesDir, "com/example/${controllerName}.class") - target.parentFile.mkdirs() - target.bytes = writer.toByteArray() - } - - private void writePlainController(String controllerName) { - ClassWriter writer = new ClassWriter(0) - writer.visit(Opcodes.V21, Opcodes.ACC_PUBLIC, "com/example/${controllerName}", null, - 'java/lang/Object', null) - writer.visitEnd() - File target = new File(classesDir, "com/example/${controllerName}.class") - target.parentFile.mkdirs() - target.bytes = writer.toByteArray() - } - - private GenerateScaffoldedViewsTask task(List overrides = [], List views = []) { - Project project = ProjectBuilder.builder().withProjectDir(projectDir).build() - project.tasks.register('generateScaffoldedViews', GenerateScaffoldedViewsTask) { - GenerateScaffoldedViewsTask it -> - it.classesDirs.from(classesDir) - it.templateClasspath.from(templateJar) - it.templateOverrides.from(overrides) - it.applicationViews.from(views) - it.outputDirectory.set(new File(projectDir, 'out')) - } - project.tasks.named('generateScaffoldedViews', GenerateScaffoldedViewsTask).get() - } - - private File generated(GenerateScaffoldedViewsTask task, String path) { - new File(task.outputDirectory.get().asFile, path) - } - - void 'a scaffolded controller gets the full set of views'() { - given: - writeController('UserController', 'User') - def task = task() - - when: - task.generate() - - then: - ['index', 'create', 'edit', 'show'].every { generated(task, "user/${it}.gsp").exists() } - } - - void 'the naming the templates read is substituted'() { - given: - writeController('UserController', 'User') - def task = task() - - when: - task.generate() - - then: - generated(task, 'user/index.gsp').text == 'list of user for User' - } - - void 'the qualified domain class is substituted, so a template can declare the type of its model'() { - given: - writeTemplateJar(templateJar, [ - index : 'model="List<${fullName}> ${propertyName}List" in ${packageName}', - create: 'create ${className}', - edit : 'edit ${className}', - show : 'show ${className}']) - writeController('UserController', 'User') - def task = task() - - when: - task.generate() - - then: 'the simple name alone would not resolve from the generated page' - generated(task, 'user/index.gsp').text == 'model="List userList" in com.example' - } - - void 'a controller without the annotation is left alone'() { - given: - writePlainController('PlainController') - def task = task() - - when: - task.generate() - - then: - !generated(task, 'plain').exists() - } - - void 'the domain class named by the annotation drives the naming, not the controller'() { - given: 'a controller whose name does not match the domain it scaffolds' - writeController('AccountController', 'Person') - def task = task() - - when: - task.generate() - - then: - generated(task, 'account/index.gsp').text == 'list of person for Person' - } - - void 'an application template overrides the one a plugin contributes'() { - given: - writeController('UserController', 'User') - File overrides = new File(projectDir, 'templates') - overrides.mkdirs() - File custom = new File(overrides, 'index.gsp') - custom.text = 'custom ${className}' - def task = task([custom]) - - when: - task.generate() - - then: - generated(task, 'user/index.gsp').text == 'custom User' - } - - void 'a view the application declares is not generated over'() { - given: 'the application writes its own index page' - writeController('UserController', 'User') - File views = new File(projectDir, 'grails-app/views/user') - views.mkdirs() - File declared = new File(views, 'index.gsp') - declared.text = 'hand written' - def task = task([], [declared]) - - when: - task.generate() - - then: 'the runtime prefers the declared page, so generating one would only shadow it' - !generated(task, 'user/index.gsp').exists() - - and: 'the views it does not declare are still generated' - generated(task, 'user/create.gsp').exists() - } - - void 'a stale view from a previous run does not survive'() { - given: - writeController('UserController', 'User') - def task = task() - task.generate() - File stale = generated(task, 'gone/index.gsp') - stale.parentFile.mkdirs() - stale.text = 'stale' - - when: - task.generate() - - then: - !stale.exists() - } -} diff --git a/grails-scaffolding/src/main/templates/scaffolding/create.gsp b/grails-scaffolding/src/main/templates/scaffolding/create.gsp index 9a140b71384..44b96f859b7 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/create.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/create.gsp @@ -1,4 +1,3 @@ -@{ model="${fullName} ${propertyName}" } diff --git a/grails-scaffolding/src/main/templates/scaffolding/edit.gsp b/grails-scaffolding/src/main/templates/scaffolding/edit.gsp index 2966da6fd49..d899b70c724 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/edit.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/edit.gsp @@ -1,4 +1,3 @@ -@{ model="${fullName} ${propertyName}" } diff --git a/grails-scaffolding/src/main/templates/scaffolding/index.gsp b/grails-scaffolding/src/main/templates/scaffolding/index.gsp index 2d4eb907ca2..c3595463718 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/index.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/index.gsp @@ -1,4 +1,3 @@ -@{ model="List<${fullName}> ${propertyName}List; Integer ${propertyName}Count" } diff --git a/grails-scaffolding/src/main/templates/scaffolding/show.gsp b/grails-scaffolding/src/main/templates/scaffolding/show.gsp index 528101a5aca..a82632d8537 100644 --- a/grails-scaffolding/src/main/templates/scaffolding/show.gsp +++ b/grails-scaffolding/src/main/templates/scaffolding/show.gsp @@ -1,4 +1,3 @@ -@{ model="${fullName} ${propertyName}" } From 79bd5b94889131fdd21001a5029259fc0f04fc5d Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Thu, 13 Aug 2026 23:55:35 -0700 Subject: [PATCH 094/115] Put the new ahead-of-time code under org.apache.grails Every package added here was a new one, so none of it carries a compatibility constraint, and each module now contributes its own package rather than extending one another jar already owns: org.grails.aot -> org.apache.grails.common.aot org.grails.spring.beans.aot -> org.apache.grails.core.aot org.grails.plugins.web.controllers.aot-> org.apache.grails.controllers.aot org.grails.gsp.aot -> org.apache.grails.gsp.aot org.grails.plugins.web.taglib.aot -> org.apache.grails.gsp.taglib.aot org.grails.web.mime.aot -> org.apache.grails.mimetypes.aot grails.plugin.scaffolding.aot -> org.apache.grails.scaffolding.aot org.grails.web.databinding.aot -> org.apache.grails.web.databinding.aot org.grails.web.mapping.aot -> org.apache.grails.web.mapping.aot org.grails.datastore.gorm.aot -> org.apache.grails.datamapping.aot grails.gorm.validation.aot -> org.apache.grails.datamapping.validation.aot The Gradle plugin classes stay in org.grails.gradle.plugin.aot, beside the rest of the plugin they belong to. That jar is a build plugin rather than something an application puts on its module path. --- .../grails/common}/aot/RegistrableTypes.java | 2 +- .../common}/aot/RegistrableTypesSpec.groovy | 4 ++-- .../aot/ControllerRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- .../aot/ControllerRuntimeHintsSpec.groovy | 2 +- .../config/GrailsAutoConfiguration.groovy | 2 +- .../AbstractBeanDefinitionExcludeFilter.java | 2 +- ...BeanFactoryInitializationAotProcessor.java | 2 +- ...owireModeBeanRegistrationAotProcessor.java | 2 +- .../core}/aot/BeanRegistrarRuntimeHints.java | 2 +- .../core}/aot/GrailsApiRuntimeHints.java | 2 +- .../core}/aot/GrailsBannerRuntimeHints.java | 2 +- .../core}/aot/GrailsClosureRuntimeHints.java | 4 ++-- .../core}/aot/GrailsResourceRuntimeHints.java | 2 +- .../GroovyExtensionModuleRuntimeHints.java | 4 ++-- .../VarargsBeanRegistrationAotProcessor.java | 2 +- .../resources/META-INF/spring/aot.factories | 20 +++++++++---------- ...ractBeanDefinitionExcludeFilterSpec.groovy | 2 +- ...ctoryInitializationAotProcessorSpec.groovy | 2 +- ...odeBeanRegistrationAotProcessorSpec.groovy | 2 +- .../aot/BeanRegistrarRuntimeHintsSpec.groovy | 2 +- .../aot/GrailsApiRuntimeHintsSpec.groovy | 2 +- .../aot/GrailsBannerRuntimeHintsSpec.groovy | 2 +- .../aot/GrailsClosureRuntimeHintsSpec.groovy | 2 +- .../aot/GrailsResourceRuntimeHintsSpec.groovy | 2 +- ...oovyExtensionModuleRuntimeHintsSpec.groovy | 2 +- ...rgsBeanRegistrationAotProcessorSpec.groovy | 2 +- .../plugins/CoreGrailsPluginAotSpec.groovy | 4 ++-- .../datamapping}/aot/GormRuntimeHints.java | 4 ++-- .../resources/META-INF/spring/aot.factories | 2 +- .../aot/GormRuntimeHintsSpec.groovy | 2 +- .../aot/ConstrainedPropertyRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- ...ConstrainedPropertyRuntimeHintsSpec.groovy | 2 +- .../gsp/aot/PrecompiledPageRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- .../PrecompiledPageRuntimeHintsSpec.groovy | 2 +- .../gsp}/taglib/aot/TagLibRuntimeHints.java | 4 ++-- .../resources/META-INF/spring/aot.factories | 2 +- .../taglib/aot/TagLibRuntimeHintsSpec.groovy | 2 +- .../mimetypes}/aot/MimeTypeRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- .../aot/ScaffoldingRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- .../aot/DataBindingRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- .../mapping/aot/UrlMappingRuntimeHints.java | 2 +- .../resources/META-INF/spring/aot.factories | 2 +- 48 files changed, 63 insertions(+), 63 deletions(-) rename grails-common/src/main/groovy/org/{grails => apache/grails/common}/aot/RegistrableTypes.java (99%) rename grails-common/src/test/groovy/org/{grails => apache/grails/common}/aot/RegistrableTypesSpec.groovy (98%) rename grails-controllers/src/main/groovy/org/{grails/plugins/web => apache/grails}/controllers/aot/ControllerRuntimeHints.java (98%) rename grails-controllers/src/test/groovy/org/{grails/plugins/web => apache/grails}/controllers/aot/ControllerRuntimeHintsSpec.groovy (98%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/AbstractBeanDefinitionExcludeFilter.java (98%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java (99%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/AutowireModeBeanRegistrationAotProcessor.java (99%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/BeanRegistrarRuntimeHints.java (98%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsApiRuntimeHints.java (99%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsBannerRuntimeHints.java (98%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsClosureRuntimeHints.java (98%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsResourceRuntimeHints.java (99%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GroovyExtensionModuleRuntimeHints.java (98%) rename grails-core/src/main/groovy/org/{grails/spring/beans => apache/grails/core}/aot/VarargsBeanRegistrationAotProcessor.java (99%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy (98%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy (99%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy (98%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/BeanRegistrarRuntimeHintsSpec.groovy (99%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsApiRuntimeHintsSpec.groovy (98%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsBannerRuntimeHintsSpec.groovy (98%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsClosureRuntimeHintsSpec.groovy (99%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GrailsResourceRuntimeHintsSpec.groovy (99%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy (99%) rename grails-core/src/test/groovy/org/{grails/spring/beans => apache/grails/core}/aot/VarargsBeanRegistrationAotProcessorSpec.groovy (99%) rename grails-datamapping-core/src/main/groovy/org/{grails/datastore/gorm => apache/grails/datamapping}/aot/GormRuntimeHints.java (98%) rename grails-datamapping-core/src/test/groovy/org/{grails/datastore/gorm => apache/grails/datamapping}/aot/GormRuntimeHintsSpec.groovy (98%) rename grails-datamapping-validation/src/main/groovy/{grails/gorm => org/apache/grails/datamapping}/validation/aot/ConstrainedPropertyRuntimeHints.java (98%) rename grails-datamapping-validation/src/test/groovy/{grails/gorm => org/apache/grails/datamapping}/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy (98%) rename grails-gsp/core/src/main/groovy/org/{ => apache}/grails/gsp/aot/PrecompiledPageRuntimeHints.java (98%) rename grails-gsp/core/src/test/groovy/org/{ => apache}/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy (98%) rename grails-gsp/plugin/src/main/groovy/org/{grails/plugins/web => apache/grails/gsp}/taglib/aot/TagLibRuntimeHints.java (98%) rename grails-gsp/plugin/src/test/groovy/org/{grails/plugins/web => apache/grails/gsp}/taglib/aot/TagLibRuntimeHintsSpec.groovy (98%) rename grails-mimetypes/src/main/groovy/org/{grails/web/mime => apache/grails/mimetypes}/aot/MimeTypeRuntimeHints.java (98%) rename grails-scaffolding/src/main/groovy/{grails/plugin => org/apache/grails}/scaffolding/aot/ScaffoldingRuntimeHints.java (98%) rename grails-web-databinding/src/main/groovy/org/{ => apache}/grails/web/databinding/aot/DataBindingRuntimeHints.java (98%) rename grails-web-url-mappings/src/main/groovy/org/{ => apache}/grails/web/mapping/aot/UrlMappingRuntimeHints.java (98%) diff --git a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java b/grails-common/src/main/groovy/org/apache/grails/common/aot/RegistrableTypes.java similarity index 99% rename from grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java rename to grails-common/src/main/groovy/org/apache/grails/common/aot/RegistrableTypes.java index 840b2b7c54b..e32f18e852f 100644 --- a/grails-common/src/main/groovy/org/grails/aot/RegistrableTypes.java +++ b/grails-common/src/main/groovy/org/apache/grails/common/aot/RegistrableTypes.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.aot; +package org.apache.grails.common.aot; import java.io.IOException; import java.io.InputStream; diff --git a/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy b/grails-common/src/test/groovy/org/apache/grails/common/aot/RegistrableTypesSpec.groovy similarity index 98% rename from grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy rename to grails-common/src/test/groovy/org/apache/grails/common/aot/RegistrableTypesSpec.groovy index 3319fa77ddc..ad6f82e7b8b 100644 --- a/grails-common/src/test/groovy/org/grails/aot/RegistrableTypesSpec.groovy +++ b/grails-common/src/test/groovy/org/apache/grails/common/aot/RegistrableTypesSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.aot +package org.apache.grails.common.aot import org.springframework.asm.ClassWriter import org.springframework.asm.Handle @@ -115,7 +115,7 @@ class RegistrableTypesSpec extends Specification { private InputStream naming(String internalName, Shape shape) { ClassWriter writer = new ClassWriter(0) writer.visit(Opcodes.V21, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, - 'org/grails/aot/Written', null, 'java/lang/Object', null) + 'org/apache/grails/common/aot/Written', null, 'java/lang/Object', null) String descriptor = "L${internalName};" switch (shape) { diff --git a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java b/grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java similarity index 98% rename from grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java rename to grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java index 6ff7b7fceab..b18db916b0e 100644 --- a/grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHints.java +++ b/grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.plugins.web.controllers.aot; +package org.apache.grails.controllers.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-controllers/src/main/resources/META-INF/spring/aot.factories b/grails-controllers/src/main/resources/META-INF/spring/aot.factories index a8cb0eb8035..b7c31695568 100644 --- a/grails-controllers/src/main/resources/META-INF/spring/aot.factories +++ b/grails-controllers/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.plugins.web.controllers.aot.ControllerRuntimeHints +org.apache.grails.controllers.aot.ControllerRuntimeHints diff --git a/grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy b/grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy similarity index 98% rename from grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy rename to grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy index 8467a537142..144e40ff4bf 100644 --- a/grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/aot/ControllerRuntimeHintsSpec.groovy +++ b/grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.plugins.web.controllers.aot +package org.apache.grails.controllers.aot import grails.artefact.controller.support.AllowedMethodsHelper diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy b/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy index 3ce991577b5..ebf0f8f7b26 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy @@ -36,7 +36,7 @@ import grails.core.GrailsApplication import grails.core.GrailsApplicationClass import org.apache.grails.core.plugins.PluginDiscovery import org.grails.spring.aop.autoproxy.GroovyAwareAspectJAwareAdvisorAutoProxyCreator -import org.grails.spring.beans.aot.ArtefactClassesBeanFactoryInitializationAotProcessor +import org.apache.grails.core.aot.ArtefactClassesBeanFactoryInitializationAotProcessor import org.grails.spring.aop.autoproxy.GroovyAwareInfrastructureAdvisorAutoProxyCreator /** diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/AbstractBeanDefinitionExcludeFilter.java similarity index 98% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/AbstractBeanDefinitionExcludeFilter.java index 58808c10676..8e6063d81d8 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilter.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/AbstractBeanDefinitionExcludeFilter.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter; import org.springframework.beans.factory.support.RegisteredBean; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java similarity index 99% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java index 1415d88e56b..48b9c14f7b1 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/ArtefactClassesBeanFactoryInitializationAotProcessor.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import java.util.ArrayList; import java.util.Arrays; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/AutowireModeBeanRegistrationAotProcessor.java similarity index 99% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/AutowireModeBeanRegistrationAotProcessor.java index 82a52b4b084..45ab7e33967 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessor.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/AutowireModeBeanRegistrationAotProcessor.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import java.util.function.Predicate; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/BeanRegistrarRuntimeHints.java similarity index 98% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/BeanRegistrarRuntimeHints.java index 361358200f2..abd904aed45 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHints.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/BeanRegistrarRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsApiRuntimeHints.java similarity index 99% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsApiRuntimeHints.java index 67b5e522947..6d29d2e346a 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHints.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsApiRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsBannerRuntimeHints.java similarity index 98% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsBannerRuntimeHints.java index c0167de49e4..f36f409992c 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHints.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsBannerRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsClosureRuntimeHints.java similarity index 98% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsClosureRuntimeHints.java index 4928450914d..bb227245f1f 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHints.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsClosureRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import java.io.IOException; @@ -34,7 +34,7 @@ import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.util.ClassUtils; -import org.grails.aot.RegistrableTypes; +import org.apache.grails.common.aot.RegistrableTypes; /** * Registers the framework closures Groovy dispatches through. diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsResourceRuntimeHints.java similarity index 99% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsResourceRuntimeHints.java index 6eb63af240d..07c8fae1747 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHints.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/GrailsResourceRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/GroovyExtensionModuleRuntimeHints.java similarity index 98% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/GroovyExtensionModuleRuntimeHints.java index c5c07fc72b5..b9fee6e8f38 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHints.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/GroovyExtensionModuleRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import java.io.IOException; import java.io.InputStream; @@ -37,7 +37,7 @@ import org.springframework.util.ClassUtils; import org.springframework.util.StringUtils; -import org.grails.aot.RegistrableTypes; +import org.apache.grails.common.aot.RegistrableTypes; /** * Registers the classes that extend types Groovy did not declare. diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java similarity index 99% rename from grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java rename to grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java index 6f5add205ac..e949166e11c 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessor.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot; +package org.apache.grails.core.aot; import java.lang.reflect.Array; import java.lang.reflect.Executable; diff --git a/grails-core/src/main/resources/META-INF/spring/aot.factories b/grails-core/src/main/resources/META-INF/spring/aot.factories index fe2a8c4bea9..ae59b173c50 100644 --- a/grails-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-core/src/main/resources/META-INF/spring/aot.factories @@ -1,17 +1,17 @@ org.springframework.beans.factory.aot.BeanRegistrationExcludeFilter=\ -org.grails.spring.beans.aot.AbstractBeanDefinitionExcludeFilter +org.apache.grails.core.aot.AbstractBeanDefinitionExcludeFilter org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.spring.beans.aot.BeanRegistrarRuntimeHints,\ -org.grails.spring.beans.aot.GrailsApiRuntimeHints,\ -org.grails.spring.beans.aot.GrailsBannerRuntimeHints,\ -org.grails.spring.beans.aot.GrailsClosureRuntimeHints,\ -org.grails.spring.beans.aot.GrailsResourceRuntimeHints,\ -org.grails.spring.beans.aot.GroovyExtensionModuleRuntimeHints +org.apache.grails.core.aot.BeanRegistrarRuntimeHints,\ +org.apache.grails.core.aot.GrailsApiRuntimeHints,\ +org.apache.grails.core.aot.GrailsBannerRuntimeHints,\ +org.apache.grails.core.aot.GrailsClosureRuntimeHints,\ +org.apache.grails.core.aot.GrailsResourceRuntimeHints,\ +org.apache.grails.core.aot.GroovyExtensionModuleRuntimeHints org.springframework.beans.factory.aot.BeanRegistrationAotProcessor=\ -org.grails.spring.beans.aot.AutowireModeBeanRegistrationAotProcessor,\ -org.grails.spring.beans.aot.VarargsBeanRegistrationAotProcessor +org.apache.grails.core.aot.AutowireModeBeanRegistrationAotProcessor,\ +org.apache.grails.core.aot.VarargsBeanRegistrationAotProcessor org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor=\ -org.grails.spring.beans.aot.ArtefactClassesBeanFactoryInitializationAotProcessor +org.apache.grails.core.aot.ArtefactClassesBeanFactoryInitializationAotProcessor diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy similarity index 98% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy index c0b0ee9de52..7bda1803f38 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/AbstractBeanDefinitionExcludeFilterSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import spock.lang.Specification diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy similarity index 99% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy index dd2813dacc0..861746179e8 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/ArtefactClassesBeanFactoryInitializationAotProcessorSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.generate.ClassNameGenerator import org.springframework.aot.generate.DefaultGenerationContext diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy similarity index 98% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy index f08b4db347d..fa9edbfd169 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/AutowireModeBeanRegistrationAotProcessorSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.beans.factory.support.AbstractBeanDefinition import org.springframework.beans.factory.support.DefaultListableBeanFactory diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/BeanRegistrarRuntimeHintsSpec.groovy similarity index 99% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/BeanRegistrarRuntimeHintsSpec.groovy index e0204de73ca..edc68eae5b9 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/BeanRegistrarRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/BeanRegistrarRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import java.util.function.Consumer diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsApiRuntimeHintsSpec.groovy similarity index 98% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsApiRuntimeHintsSpec.groovy index 2ff8daf8fb1..2326704a818 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsApiRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsApiRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsBannerRuntimeHintsSpec.groovy similarity index 98% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsBannerRuntimeHintsSpec.groovy index 7545a368bfa..e59786e3643 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsBannerRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsBannerRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsClosureRuntimeHintsSpec.groovy similarity index 99% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsClosureRuntimeHintsSpec.groovy index c489ed120d7..6b071e6a10c 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsClosureRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsClosureRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsResourceRuntimeHintsSpec.groovy similarity index 99% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsResourceRuntimeHintsSpec.groovy index c2a4c9f4470..ca806e40ae3 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GrailsResourceRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/GrailsResourceRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.hint.RuntimeHints import org.springframework.core.SpringProperties diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy similarity index 99% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy index d73e1b14617..745452b855d 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/GroovyExtensionModuleRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy b/grails-core/src/test/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessorSpec.groovy similarity index 99% rename from grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy rename to grails-core/src/test/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessorSpec.groovy index f24d672738d..734335ad381 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/aot/VarargsBeanRegistrationAotProcessorSpec.groovy +++ b/grails-core/src/test/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessorSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.spring.beans.aot +package org.apache.grails.core.aot import org.springframework.aot.generate.ClassNameGenerator import org.springframework.aot.generate.DefaultGenerationContext diff --git a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy index 32395f089a5..6d8fef80df6 100644 --- a/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/plugins/CoreGrailsPluginAotSpec.groovy @@ -149,7 +149,7 @@ class CoreGrailsPluginAotSpec extends Specification { and: def generationContext = new DefaultGenerationContext( - new ClassNameGenerator(ClassName.get('org.grails.aot.test', 'CoreAotTest')), + new ClassNameGenerator(ClassName.get('org.apache.grails.common.aot.test', 'CoreAotTest')), new InMemoryGeneratedFiles()) when: 'the context is processed exactly as the processAot build task processes it' @@ -173,7 +173,7 @@ class CoreGrailsPluginAotSpec extends Specification { and: def generationContext = new DefaultGenerationContext( - new ClassNameGenerator(ClassName.get('org.grails.aot.test', 'LiveInstanceAotTest')), + new ClassNameGenerator(ClassName.get('org.apache.grails.common.aot.test', 'LiveInstanceAotTest')), new InMemoryGeneratedFiles()) when: diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java b/grails-datamapping-core/src/main/groovy/org/apache/grails/datamapping/aot/GormRuntimeHints.java similarity index 98% rename from grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java rename to grails-datamapping-core/src/main/groovy/org/apache/grails/datamapping/aot/GormRuntimeHints.java index 2ebfee041e4..36f63988c3d 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/aot/GormRuntimeHints.java +++ b/grails-datamapping-core/src/main/groovy/org/apache/grails/datamapping/aot/GormRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.datastore.gorm.aot; +package org.apache.grails.datamapping.aot; import java.io.IOException; @@ -34,7 +34,7 @@ import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.util.ClassUtils; -import org.grails.aot.RegistrableTypes; +import org.apache.grails.common.aot.RegistrableTypes; /** * Registers the persistence runtime a datastore reaches through Groovy. diff --git a/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories b/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories index 2161ffba18f..304b1002ba3 100644 --- a/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-datamapping-core/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.datastore.gorm.aot.GormRuntimeHints +org.apache.grails.datamapping.aot.GormRuntimeHints diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy b/grails-datamapping-core/src/test/groovy/org/apache/grails/datamapping/aot/GormRuntimeHintsSpec.groovy similarity index 98% rename from grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy rename to grails-datamapping-core/src/test/groovy/org/apache/grails/datamapping/aot/GormRuntimeHintsSpec.groovy index 3f106982a57..9197b24a041 100644 --- a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/aot/GormRuntimeHintsSpec.groovy +++ b/grails-datamapping-core/src/test/groovy/org/apache/grails/datamapping/aot/GormRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.datastore.gorm.aot +package org.apache.grails.datamapping.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints diff --git a/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java b/grails-datamapping-validation/src/main/groovy/org/apache/grails/datamapping/validation/aot/ConstrainedPropertyRuntimeHints.java similarity index 98% rename from grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java rename to grails-datamapping-validation/src/main/groovy/org/apache/grails/datamapping/validation/aot/ConstrainedPropertyRuntimeHints.java index 55df42ba26b..f71c7934bbc 100644 --- a/grails-datamapping-validation/src/main/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHints.java +++ b/grails-datamapping-validation/src/main/groovy/org/apache/grails/datamapping/validation/aot/ConstrainedPropertyRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package grails.gorm.validation.aot; +package org.apache.grails.datamapping.validation.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories b/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories index 245d6f5cffe..ca414e7b1e8 100644 --- a/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories +++ b/grails-datamapping-validation/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -grails.gorm.validation.aot.ConstrainedPropertyRuntimeHints +org.apache.grails.datamapping.validation.aot.ConstrainedPropertyRuntimeHints diff --git a/grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy b/grails-datamapping-validation/src/test/groovy/org/apache/grails/datamapping/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy similarity index 98% rename from grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy rename to grails-datamapping-validation/src/test/groovy/org/apache/grails/datamapping/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy index 2f2a4b47369..be3f357e5e4 100644 --- a/grails-datamapping-validation/src/test/groovy/grails/gorm/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy +++ b/grails-datamapping-validation/src/test/groovy/org/apache/grails/datamapping/validation/aot/ConstrainedPropertyRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package grails.gorm.validation.aot +package org.apache.grails.datamapping.validation.aot import grails.gorm.validation.DefaultConstrainedProperty diff --git a/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java b/grails-gsp/core/src/main/groovy/org/apache/grails/gsp/aot/PrecompiledPageRuntimeHints.java similarity index 98% rename from grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java rename to grails-gsp/core/src/main/groovy/org/apache/grails/gsp/aot/PrecompiledPageRuntimeHints.java index 111bdfc450d..857ab6478af 100644 --- a/grails-gsp/core/src/main/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHints.java +++ b/grails-gsp/core/src/main/groovy/org/apache/grails/gsp/aot/PrecompiledPageRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gsp.aot; +package org.apache.grails.gsp.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories b/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories index 178ec340883..8354358b6cd 100644 --- a/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories +++ b/grails-gsp/core/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.gsp.aot.PrecompiledPageRuntimeHints +org.apache.grails.gsp.aot.PrecompiledPageRuntimeHints diff --git a/grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy b/grails-gsp/core/src/test/groovy/org/apache/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy similarity index 98% rename from grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy rename to grails-gsp/core/src/test/groovy/org/apache/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy index 9eea0dbe87b..07faf4c337e 100644 --- a/grails-gsp/core/src/test/groovy/org/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy +++ b/grails-gsp/core/src/test/groovy/org/apache/grails/gsp/aot/PrecompiledPageRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gsp.aot +package org.apache.grails.gsp.aot import org.springframework.aot.hint.RuntimeHints import org.springframework.aot.hint.predicate.RuntimeHintsPredicates diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java b/grails-gsp/plugin/src/main/groovy/org/apache/grails/gsp/taglib/aot/TagLibRuntimeHints.java similarity index 98% rename from grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java rename to grails-gsp/plugin/src/main/groovy/org/apache/grails/gsp/taglib/aot/TagLibRuntimeHints.java index 1429d9a1087..582c0042677 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHints.java +++ b/grails-gsp/plugin/src/main/groovy/org/apache/grails/gsp/taglib/aot/TagLibRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.plugins.web.taglib.aot; +package org.apache.grails.gsp.taglib.aot; import java.io.IOException; @@ -34,7 +34,7 @@ import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.util.ClassUtils; -import org.grails.aot.RegistrableTypes; +import org.apache.grails.common.aot.RegistrableTypes; /** * Registers the tag libraries and page runtime a rendered page dispatches through. diff --git a/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories b/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories index e56c5b482c9..ca1a51059d3 100644 --- a/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories +++ b/grails-gsp/plugin/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.plugins.web.taglib.aot.TagLibRuntimeHints +org.apache.grails.gsp.taglib.aot.TagLibRuntimeHints diff --git a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy b/grails-gsp/plugin/src/test/groovy/org/apache/grails/gsp/taglib/aot/TagLibRuntimeHintsSpec.groovy similarity index 98% rename from grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy rename to grails-gsp/plugin/src/test/groovy/org/apache/grails/gsp/taglib/aot/TagLibRuntimeHintsSpec.groovy index 2b63d2408a4..58a68ac461c 100644 --- a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/taglib/aot/TagLibRuntimeHintsSpec.groovy +++ b/grails-gsp/plugin/src/test/groovy/org/apache/grails/gsp/taglib/aot/TagLibRuntimeHintsSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.plugins.web.taglib.aot +package org.apache.grails.gsp.taglib.aot import org.springframework.aot.hint.MemberCategory import org.springframework.aot.hint.RuntimeHints diff --git a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java b/grails-mimetypes/src/main/groovy/org/apache/grails/mimetypes/aot/MimeTypeRuntimeHints.java similarity index 98% rename from grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java rename to grails-mimetypes/src/main/groovy/org/apache/grails/mimetypes/aot/MimeTypeRuntimeHints.java index 80b40ef22c2..c2cf0997b9b 100644 --- a/grails-mimetypes/src/main/groovy/org/grails/web/mime/aot/MimeTypeRuntimeHints.java +++ b/grails-mimetypes/src/main/groovy/org/apache/grails/mimetypes/aot/MimeTypeRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.web.mime.aot; +package org.apache.grails.mimetypes.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories b/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories index e6d118d9714..4ca6a258b7e 100644 --- a/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories +++ b/grails-mimetypes/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.web.mime.aot.MimeTypeRuntimeHints +org.apache.grails.mimetypes.aot.MimeTypeRuntimeHints diff --git a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java b/grails-scaffolding/src/main/groovy/org/apache/grails/scaffolding/aot/ScaffoldingRuntimeHints.java similarity index 98% rename from grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java rename to grails-scaffolding/src/main/groovy/org/apache/grails/scaffolding/aot/ScaffoldingRuntimeHints.java index a8b018804cb..b684a97b2e8 100644 --- a/grails-scaffolding/src/main/groovy/grails/plugin/scaffolding/aot/ScaffoldingRuntimeHints.java +++ b/grails-scaffolding/src/main/groovy/org/apache/grails/scaffolding/aot/ScaffoldingRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package grails.plugin.scaffolding.aot; +package org.apache.grails.scaffolding.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories b/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories index 85ba8176d40..c598be8d2ee 100644 --- a/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories +++ b/grails-scaffolding/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -grails.plugin.scaffolding.aot.ScaffoldingRuntimeHints +org.apache.grails.scaffolding.aot.ScaffoldingRuntimeHints diff --git a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java b/grails-web-databinding/src/main/groovy/org/apache/grails/web/databinding/aot/DataBindingRuntimeHints.java similarity index 98% rename from grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java rename to grails-web-databinding/src/main/groovy/org/apache/grails/web/databinding/aot/DataBindingRuntimeHints.java index 49e004e19cf..afe51a92173 100644 --- a/grails-web-databinding/src/main/groovy/org/grails/web/databinding/aot/DataBindingRuntimeHints.java +++ b/grails-web-databinding/src/main/groovy/org/apache/grails/web/databinding/aot/DataBindingRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.web.databinding.aot; +package org.apache.grails.web.databinding.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories b/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories index 09045e2d0db..2f54037435d 100644 --- a/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories +++ b/grails-web-databinding/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.web.databinding.aot.DataBindingRuntimeHints +org.apache.grails.web.databinding.aot.DataBindingRuntimeHints diff --git a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java b/grails-web-url-mappings/src/main/groovy/org/apache/grails/web/mapping/aot/UrlMappingRuntimeHints.java similarity index 98% rename from grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java rename to grails-web-url-mappings/src/main/groovy/org/apache/grails/web/mapping/aot/UrlMappingRuntimeHints.java index 14fd803f69a..2124937fa4b 100644 --- a/grails-web-url-mappings/src/main/groovy/org/grails/web/mapping/aot/UrlMappingRuntimeHints.java +++ b/grails-web-url-mappings/src/main/groovy/org/apache/grails/web/mapping/aot/UrlMappingRuntimeHints.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.web.mapping.aot; +package org.apache.grails.web.mapping.aot; import org.jspecify.annotations.Nullable; diff --git a/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories b/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories index f1d12f9db9c..aca4230fb28 100644 --- a/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories +++ b/grails-web-url-mappings/src/main/resources/META-INF/spring/aot.factories @@ -1,2 +1,2 @@ org.springframework.aot.hint.RuntimeHintsRegistrar=\ -org.grails.web.mapping.aot.UrlMappingRuntimeHints +org.apache.grails.web.mapping.aot.UrlMappingRuntimeHints From 1714f2b055d1e3129476d77ebfe1e554432211a9 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 14 Aug 2026 00:07:41 -0700 Subject: [PATCH 095/115] Leave one thing deciding what the definitions are generated for Three mechanisms answered the same question. grails.env=production is set on processAot by the Gradle plugin; the same property was set again by hand in the example application; and UrlMappingsGrailsPlugin asked separately whether code was being generated. Only the first is load-bearing. With it set, the plugin's own check changes nothing -- the environment is already not a reloading one -- so the check, the two seams it was reached through and the tests that covered them are gone, and that file is back to what it was. The example application no longer repeats what the plugin does. The check in the GSP plugin is not the same and stays. It asks whether the code is being generated, which is not a question about the environment: isDevelopmentEnvironmentAvailable() asks whether grails-app is on disk, and while generating it is. Removing it does not fail the build -- it writes the directory the build ran in into groovyPageResourceLoader: addPropertyValue("baseResource", "file:/home/build/app/") which starts cleanly on the machine that generated it and looks for its pages in a directory that does not exist anywhere else. A check on the generated sources now fails the example application's build if anything writes a build path into them, since nothing else would say so. The guide no longer asks for a property the plugin already sets. --- .../en/guide/deployment/deploymentAot.adoc | 22 ++++----- grails-test-examples/aot/build.gradle | 35 ++++++++++++--- .../mapping/UrlMappingsGrailsPlugin.groovy | 24 +--------- .../UrlMappingsGrailsPluginSpec.groovy | 45 ------------------- 4 files changed, 43 insertions(+), 83 deletions(-) diff --git a/grails-doc/src/en/guide/deployment/deploymentAot.adoc b/grails-doc/src/en/guide/deployment/deploymentAot.adoc index ac4b62c4c60..99c2d6bfded 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAot.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAot.adoc @@ -44,19 +44,12 @@ java -Dspring.aot.enabled=true -jar build/libs/myapp.jar An application started this way logs `Starting AOT-processed Application` rather than `Starting Application`. -=== Generate in production mode +=== The environment the definitions are generated for -`processAot` builds the bean definitions that the packaged application will use, so it must run with the same environment those definitions are meant for: +`processAot` builds the bean definitions the packaged application will use, so it runs in the environment those definitions are meant for. The Grails Gradle plugin sets `grails.env` to `production` on the task; nothing needs to be configured for it. -[source,groovy] ----- -tasks.named('processAot') { - systemProperty 'grails.env', 'production' -} ----- - -Without this the task runs in the development environment, where reloading is enabled and several beans take a different shape. The URL mappings holder, for example, becomes a proxy whose type cannot be determined without creating it, and generation fails with an error naming a bean that is unrelated to anything in the application: +It matters because an application declares different beans in different environments. Under development the URL mappings holder is a proxy whose type cannot be determined without creating it, and generation fails naming a bean unrelated to anything in the application: [source] ---- @@ -64,7 +57,14 @@ Field urlMappings in org.grails.web.mapping.servlet.UrlMappingsErrorPageCustomiz required a bean of type 'grails.web.mapping.UrlMappings' that could not be found. ---- -Reload-mode beans have no meaning in a packaged artifact, so generating in production mode is correct as well as necessary. +Reload-mode beans have no meaning in a packaged artifact, so generating in production is correct as well as necessary. To generate for a different environment, set the property on the task yourself: + +[source,groovy] +---- +tasks.named('processAot') { + systemProperty 'grails.env', 'staging' +} +---- === What AOT changes at runtime diff --git a/grails-test-examples/aot/build.gradle b/grails-test-examples/aot/build.gradle index 18fee968659..259fc2066a9 100644 --- a/grails-test-examples/aot/build.gradle +++ b/grails-test-examples/aot/build.gradle @@ -44,11 +44,36 @@ dependencies { testImplementation 'org.apache.grails:grails-testing-support-web' } -// Generation reflects the environment the packaged application runs in. Under development, -// reloading is enabled and beans such as the url mappings holder take a proxied shape that has -// no meaning in a packaged artifact and cannot be generated. -tasks.named('processAot') { - systemProperty 'grails.env', 'production' + +// A generated definition holding a path from the machine that generated it builds cleanly, starts +// cleanly on that machine, and fails everywhere else -- so nothing but looking at what was written +// catches it. This is what the AOT_PROCESSING checks in the plugins are for. +tasks.register('aotGeneratedSourcesCarryNoBuildPath') { + group = 'verification' + description = 'Asserts the generated bean definitions hold no path from the machine that generated them' + dependsOn tasks.named('processAot') + def generated = layout.buildDirectory.dir('generated/aotSources') + def buildPath = projectDir.absolutePath + inputs.dir(generated).withPropertyName('generatedSources') + .withPathSensitivity(PathSensitivity.RELATIVE) + doLast { + List carrying = [] + generated.get().asFile.eachFileRecurse { file -> + if (file.name.endsWith('.java') && file.text.contains(buildPath)) { + carrying << file + } + } + if (carrying) { + throw new GradleException( + "Generated bean definitions carry the directory they were generated in, so the " + + "application would look for its resources there wherever it runs:\n " + + carrying.join('\n ')) + } + } +} + +tasks.named('check') { + dependsOn tasks.named('aotGeneratedSourcesCarryNoBuildPath') } // The application must also start from what was generated, which is the half that catches a diff --git a/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy b/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy index 24b7680c775..1824e739b36 100644 --- a/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy +++ b/grails-url-mappings/src/main/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPlugin.groovy @@ -30,8 +30,6 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication import org.springframework.boot.context.properties.EnableConfigurationProperties import org.springframework.context.ApplicationContext -import org.springframework.context.aot.AbstractAotProcessor -import org.springframework.core.SpringProperties import org.springframework.core.env.Environment import org.springframework.web.filter.CorsFilter @@ -119,7 +117,8 @@ class UrlMappingsGrailsPlugin extends Plugin { grailsApplication.addArtefact(UrlMappingsArtefactHandler.TYPE, DefaultUrlMappings) } - boolean reloadEnabled = isReloadEnabled() + boolean reloadEnabled = GrailsEnvironment.developmentMode || + GrailsEnvironment.current.reloadEnabled boolean corsFilterEnabled = environment.getProperty(Settings.SETTING_CORS_FILTER, Boolean, true) // The url-mapping holder is a ProxyFactoryBean (reload mode) whose produced UrlMappings @@ -156,25 +155,6 @@ class UrlMappingsGrailsPlugin extends Plugin { } } - /** - * Whether the mappings are to be reloadable, which decides how the holder is defined. - * - *

    Not while the code is being generated, whatever the machine generating it looks like. - * Reloading swaps the mappings behind a proxy, and the proxy produces its {@code UrlMappings} - * through a target source rather than declaring the type -- so Spring can only learn what it - * produces by building it, which is exactly what reading a generated definition avoids. - * Generated that way nothing could be autowired by that type, and the application did not - * start. An image cannot reload anything in any case.

    - */ - protected boolean isReloadEnabled() { - !SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING) && environmentReloadable - } - - /** Whether the surroundings are ones that reload, which only a run can answer. */ - protected boolean isEnvironmentReloadable() { - GrailsEnvironment.developmentMode || GrailsEnvironment.current.reloadEnabled - } - @CompileStatic private static UrlMappingsHolder createUrlMappingsHolder(ApplicationContext applicationContext) { def factory = new UrlMappingsHolderFactoryBean(applicationContext: applicationContext) diff --git a/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy b/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy index f4a97541762..289100a3f0b 100644 --- a/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy +++ b/grails-url-mappings/src/test/groovy/org/grails/plugins/web/mapping/UrlMappingsGrailsPluginSpec.groovy @@ -23,7 +23,6 @@ import org.springframework.beans.factory.config.RuntimeBeanReference import org.springframework.beans.factory.support.AbstractBeanDefinition import org.springframework.beans.factory.support.BeanRegistryAdapter import org.springframework.beans.factory.support.DefaultListableBeanFactory -import org.springframework.context.aot.AbstractAotProcessor import org.springframework.core.env.StandardEnvironment import grails.core.GrailsApplication @@ -104,50 +103,6 @@ class UrlMappingsGrailsPluginSpec extends Specification { !registry.containsBeanDefinition('urlMappingsTargetSource') } - void "reloading is off while the code is being generated"() { - given: "surroundings that would otherwise reload" - def plugin = new Reloading() - - expect: "which is how the holder comes to be a proxy" - plugin.isReloadEnabled() - - when: "the same surroundings, while the code is being generated" - System.setProperty(AbstractAotProcessor.AOT_PROCESSING, 'true') - - then: "the proxy produces its UrlMappings through a target source rather than declaring the " + - "type, so nothing could be autowired by that type from a generated definition" - !plugin.isReloadEnabled() - - cleanup: - System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) - } - - void "the surroundings still decide on an ordinary start"() { - given: - System.clearProperty(AbstractAotProcessor.AOT_PROCESSING) - - expect: "generation is the only thing that overrides them" - new Reloading().isReloadEnabled() - !new NotReloading().isReloadEnabled() - } - - /** Stands in for surroundings that reload, which a test JVM is not. */ - static class Reloading extends UrlMappingsGrailsPlugin { - - @Override - protected boolean isEnvironmentReloadable() { - true - } - } - - static class NotReloading extends UrlMappingsGrailsPlugin { - - @Override - protected boolean isEnvironmentReloadable() { - false - } - } - private static void applyRegistrar(DefaultListableBeanFactory beanFactory, GrailsApplication application) { def plugin = new UrlMappingsGrailsPlugin(grailsApplication: application) def registrar = plugin.beanRegistrar() From d81902f70b65b5b717c77255e9ed9cfdcc204cba Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 14 Aug 2026 00:12:39 -0700 Subject: [PATCH 096/115] Ask in one place whether the code is being written out Three places read SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING), each carrying its own explanation of what the flag means. Spring sets it around its own processing and offers no predicate for it, so the reading of it now lives in grails-common beside the other shared ahead-of-time code, which is where GORM and the framework both already reach. AbstractDatastoreInitializer.configurationReference also moves out from between two field declarations to sit with the other methods. --- .../common/aot/AheadOfTimeProcessing.java | 54 ++++++++++++++++++ .../AbstractResourceLocatorPostProcessor.java | 7 +-- .../AbstractDatastoreInitializer.groovy | 56 +++++++++---------- .../web/GroovyPagesGrailsPlugin.groovy | 5 +- 4 files changed, 86 insertions(+), 36 deletions(-) create mode 100644 grails-common/src/main/groovy/org/apache/grails/common/aot/AheadOfTimeProcessing.java diff --git a/grails-common/src/main/groovy/org/apache/grails/common/aot/AheadOfTimeProcessing.java b/grails-common/src/main/groovy/org/apache/grails/common/aot/AheadOfTimeProcessing.java new file mode 100644 index 00000000000..29441158908 --- /dev/null +++ b/grails-common/src/main/groovy/org/apache/grails/common/aot/AheadOfTimeProcessing.java @@ -0,0 +1,54 @@ +/* + * 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.common.aot; + +import org.springframework.context.aot.AbstractAotProcessor; +import org.springframework.core.SpringProperties; + +/** + * Whether the application's code is being written out rather than run. + * + *

    A bean definition is read here to be turned into source, so anything it holds is written into + * the artifact and carried wherever that artifact goes. Two kinds of value must not be: one that + * describes the machine doing the writing -- a directory it built in, the environment it had -- and + * one that cannot be expressed as code at all.

    + * + *

    This is not a question about the environment. An application generates its definitions in + * production and is still being generated rather than served, and the things that must not be + * written down are the same either way: the sources are on disk while generating, so everything + * that asks whether they are answers yes.

    + * + *

    Spring sets the flag around its own processing and does not offer a predicate for it, so the + * reading of it lives here rather than in each place that has to ask.

    + * + * @since 8.0 + */ +public final class AheadOfTimeProcessing { + + private AheadOfTimeProcessing() { + } + + /** + * @return whether this is running inside ahead-of-time processing rather than in an application + */ + public static boolean isGeneratingCode() { + return SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING); + } + +} diff --git a/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java b/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java index b53bec5af07..8ffb53d34b5 100644 --- a/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java +++ b/grails-core/src/main/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessor.java @@ -26,9 +26,9 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.beans.factory.support.GenericBeanDefinition; -import org.springframework.context.aot.AbstractAotProcessor; import org.springframework.core.PriorityOrdered; -import org.springframework.core.SpringProperties; + +import org.apache.grails.common.aot.AheadOfTimeProcessing; /** * Registers {@code abstractGrailsResourceLocator}, the abstract parent definition that @@ -78,8 +78,7 @@ public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) t * to look.

    */ private List searchLocationsToInherit() { - return SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING) ? - List.of() : this.searchLocations; + return AheadOfTimeProcessing.isGeneratingCode() ? List.of() : this.searchLocations; } /** diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy index 6655a7f1756..fdf64444f19 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/bootstrap/AbstractDatastoreInitializer.groovy @@ -31,10 +31,8 @@ import org.springframework.context.ApplicationEventPublisher import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.MessageSource import org.springframework.context.ResourceLoaderAware -import org.springframework.context.aot.AbstractAotProcessor import org.springframework.context.support.GenericApplicationContext import org.springframework.context.support.StaticMessageSource -import org.springframework.core.SpringProperties import org.springframework.core.env.ConfigurableEnvironment import org.springframework.core.env.PropertyResolver import org.springframework.core.env.StandardEnvironment @@ -46,6 +44,7 @@ import org.springframework.core.type.classreading.CachingMetadataReaderFactory import org.springframework.util.ClassUtils import grails.gorm.annotation.Entity +import org.apache.grails.common.aot.AheadOfTimeProcessing import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher import org.grails.datastore.gorm.plugin.support.PersistenceContextInterceptorAggregator @@ -80,33 +79,6 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { Collection persistentClasses = [] Collection packages = [] PropertyResolver configuration = new StandardEnvironment() - - /** - * What a bean definition should hold in place of the configuration itself. - * - *

    A definition holding the resolver is a definition holding everything the resolver can - * reach, and generating code for such a definition writes those values out: an environment - * carries the machine's own variables, so the generated source ends up containing the - * environment of whatever machine built it, along with whatever was in it -- credentials among - * them -- and the application then reads its settings from there rather than from where it - * runs.

    - * - *

    So while code is being generated, and only then, the context's environment is named - * instead, which leaves the lookup to be made where the application runs. Every other time the - * resolver is held as it always was, which matters for a datastore brought up on its own: its - * configuration is whatever the caller passed and there is no environment holding it.

    - */ - protected Object configurationReference(BeanDefinitionRegistry registry) { - if (!SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING)) { - return configuration - } - boolean insideContainer = registry instanceof ConfigurableApplicationContext || - resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext - insideContainer - ? new RuntimeBeanReference(ConfigurableApplicationContext.ENVIRONMENT_BEAN_NAME) - : configuration - } - boolean registerApplicationIfNotPresent = true Object originalConfiguration @@ -155,6 +127,32 @@ abstract class AbstractDatastoreInitializer implements ResourceLoaderAware { this(configuration, persistentClasses.toList()) } + /** + * What a bean definition should hold in place of the configuration itself. + * + *

    A definition holding the resolver is a definition holding everything the resolver can + * reach, and generating code for such a definition writes those values out: an environment + * carries the machine's own variables, so the generated source ends up containing the + * environment of whatever machine built it, along with whatever was in it -- credentials among + * them -- and the application then reads its settings from there rather than from where it + * runs.

    + * + *

    So while code is being generated, and only then, the context's environment is named + * instead, which leaves the lookup to be made where the application runs. Every other time the + * resolver is held as it always was, which matters for a datastore brought up on its own: its + * configuration is whatever the caller passed and there is no environment holding it.

    + */ + protected Object configurationReference(BeanDefinitionRegistry registry) { + if (!AheadOfTimeProcessing.generatingCode) { + return configuration + } + boolean insideContainer = registry instanceof ConfigurableApplicationContext || + resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext + insideContainer + ? new RuntimeBeanReference(ConfigurableApplicationContext.ENVIRONMENT_BEAN_NAME) + : configuration + } + /** * Finds the event publisher to use * diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index ae982ed436c..c7e24dedc41 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -25,8 +25,6 @@ import org.springframework.beans.factory.BeanRegistry import org.springframework.beans.factory.BeanRegistrar import org.springframework.beans.factory.config.PropertiesFactoryBean import org.springframework.boot.web.servlet.ServletRegistrationBean -import org.springframework.context.aot.AbstractAotProcessor -import org.springframework.core.SpringProperties import org.springframework.util.ClassUtils import org.springframework.web.servlet.view.InternalResourceViewResolver @@ -39,6 +37,7 @@ import grails.util.Environment import grails.util.GrailsUtil import grails.util.Metadata import grails.web.pages.GroovyPagesUriService +import org.apache.grails.common.aot.AheadOfTimeProcessing import org.grails.core.artefact.gsp.TagLibArtefactHandler import org.grails.gsp.GroovyPageResourceLoader import org.grails.gsp.GroovyPagesTemplateEngine @@ -292,7 +291,7 @@ class GroovyPagesGrailsPlugin extends Plugin { */ @CompileStatic protected boolean isDevelopmentMode() { - if (SpringProperties.getFlag(AbstractAotProcessor.AOT_PROCESSING)) { + if (AheadOfTimeProcessing.generatingCode) { return false } Metadata.getCurrent().isDevelopmentEnvironmentAvailable() From 437e627074848756ef52f71fe80ecfc45cc02af0 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 14 Aug 2026 00:18:20 -0700 Subject: [PATCH 097/115] Say unknown where a version was asked for, and nothing where it was not A version that could not be determined was left out either way. Leaving out a default is what lets one be shown at all -- an application without Spring Security says nothing about it rather than saying it does not know. Leaving out one the application named itself is different: it reads as the option having been ignored, which is the very thing an unrecognised option is now warned about. So a version asked for by name reads unknown, and only the defaults are left out. The version lookups move out of createBannerVersions into versionsFor, since deciding this per option needs the option that produced a label. Also gone: colouring an image's output when TERM is set. It cannot tell output being watched from output being redirected, so it wrote escapes into a redirected log; an image that should be coloured can be told so with spring.output.ansi.enabled, which is Spring Boot's own property and needs nothing here. The two seams that existed for a spec to override go with it. And VarargsBeanRegistrationAotProcessor no longer catches Throwable. It meant to tolerate a bean class that will not resolve, which is an Exception; an Error is a JVM out of memory or a class that will not link, and neither is a bean without a variable-argument constructor. A debug line is left so a genuinely broken bean can be traced to here. --- .../groovy/grails/boot/GrailsBanner.groovy | 98 ++++++++------- .../GrailsEnvironmentPostProcessor.java | 46 ------- .../VarargsBeanRegistrationAotProcessor.java | 17 ++- .../boot/GrailsBannerNativeMarkSpec.groovy | 16 ++- ...ilsEnvironmentPostProcessorAnsiSpec.groovy | 114 ------------------ .../src/en/guide/introduction/whatsNew.adoc | 6 +- .../src/en/guide/upgrading/upgrading80x.adoc | 8 +- 7 files changed, 91 insertions(+), 214 deletions(-) delete mode 100644 grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy index fe126b45870..b6bfbbeaa31 100644 --- a/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy +++ b/grails-core/src/main/groovy/grails/boot/GrailsBanner.groovy @@ -72,6 +72,9 @@ class GrailsBanner implements Banner { private static final String NO_COLOR = 'none' + /** Shown where an application asked for a version by name and it could not be determined. */ + private static final String UNKNOWN_VERSION = 'unknown' + private static final String ORDER_PROPERTY = 'grails.banner.versions.order' private static final String EXCLUDE_PROPERTY = 'grails.banner.versions.exclude' @@ -342,49 +345,60 @@ class GrailsBanner implements Banner { } } } - // A library that is not there, or that records no version, is left out rather than shown - // as unknown. That is what lets a version be on by default: an application without Spring - // Security says nothing about it, instead of saying it does not know. - Map versions = includedVersions.collectEntries { key -> - switch (VersionOption.fromString(key)) { - case VersionOption.APP: - [(env.getProperty('info.app.name') ?: 'app'): env.getProperty('info.app.version') ?: 'unknown'] - break - case VersionOption.JVM: - ['JVM': System.getProperty('java.vendor') + ' ' + System.getProperty('java.version')] - break - case VersionOption.GRAILS: - ['Grails': BuildSettings.grailsVersion] - break - case VersionOption.GROOVY: - ['Groovy': GroovySystem.version] - break - case VersionOption.SPRING_BOOT: - ['Spring Boot': SpringBootVersion.version] - break - case VersionOption.SPRING: - ['Spring': SpringVersion.version] - break - case VersionOption.SPRING_SECURITY: - ['Spring Security': findVersion('org.springframework.security.core.SpringSecurityCoreVersion')] - break - case VersionOption.CONTAINER: - findContainerVersion() - break - case VersionOption.TOMCAT: - ['Tomcat': findTomcatVersion()] - break - case VersionOption.JETTY: - ['Jetty': findJettyVersion()] - break - case VersionOption.UNDERTOW: - ['Undertow': findUndertowVersion()] - break - default: - null + // A version that cannot be determined is left out where it is shown by default, and shown + // as unknown where the application asked for it by name. Leaving out a default is what + // lets one be on at all -- an application without Spring Security says nothing about it + // rather than saying it does not know -- but leaving out one that was asked for reads as + // the option having been ignored, which is the thing an unrecognised option is warned about. + Map versions = [:] + for (String key : includedVersions) { + versionsFor(key, env).each { String label, String version -> + if (version != null) { + versions[label] = version + } + else if (key in configIncluded) { + versions[label] = UNKNOWN_VERSION + } } - } as Map - versions.findAll { String label, String version -> version != null } + } + versions + } + + /** + * What one version option contributes, as the labels it is shown under and what each records. + * + *

    A value of {@code null} is a library that is absent or records nothing; the caller decides + * whether that is left out or shown as unknown. An option that contributes nothing at all -- + * the container, where none of them is there -- contributes no label to decide about.

    + */ + protected Map versionsFor(String key, Environment env) { + switch (VersionOption.fromString(key)) { + case VersionOption.APP: + String appName = env.getProperty('info.app.name') ?: 'app' + return [(appName): env.getProperty('info.app.version') ?: UNKNOWN_VERSION] + case VersionOption.JVM: + return ['JVM': System.getProperty('java.vendor') + ' ' + System.getProperty('java.version')] + case VersionOption.GRAILS: + return ['Grails': BuildSettings.grailsVersion] + case VersionOption.GROOVY: + return ['Groovy': GroovySystem.version] + case VersionOption.SPRING_BOOT: + return ['Spring Boot': SpringBootVersion.version] + case VersionOption.SPRING: + return ['Spring': SpringVersion.version] + case VersionOption.SPRING_SECURITY: + return ['Spring Security': findVersion('org.springframework.security.core.SpringSecurityCoreVersion')] + case VersionOption.CONTAINER: + return findContainerVersion() + case VersionOption.TOMCAT: + return ['Tomcat': findTomcatVersion()] + case VersionOption.JETTY: + return ['Jetty': findJettyVersion()] + case VersionOption.UNDERTOW: + return ['Undertow': findUndertowVersion()] + default: + return [:] + } } /** diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java b/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java index ee823f1a5e7..2650bb300be 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsEnvironmentPostProcessor.java @@ -22,7 +22,6 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -33,7 +32,6 @@ import org.springframework.core.Ordered; import org.springframework.core.env.ConfigurableEnvironment; import org.springframework.core.env.EnumerablePropertySource; -import org.springframework.core.env.MapPropertySource; import org.springframework.core.env.MutablePropertySources; import org.springframework.core.env.PropertySource; import org.springframework.core.io.Resource; @@ -76,15 +74,8 @@ public int getOrder() { return Ordered.HIGHEST_PRECEDENCE + 15; } - /** Where Spring Boot reads whether to colour its output. */ - private static final String ANSI_ENABLED = "spring.output.ansi.enabled"; - - /** Set in an image, and in nothing else. */ - private static final String IMAGE_CODE = "org.graalvm.nativeimage.imagecode"; - @Override public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { - colourTheOutputOfAnImageThatHasATerminal(environment); try { PluginDiscovery pluginDiscovery = bootstrapContext.get(PluginDiscovery.class); if (pluginDiscovery == null) { @@ -101,43 +92,6 @@ public void postProcessEnvironment(ConfigurableEnvironment environment, SpringAp } } - /** - * Colours the output of an image running at a terminal, which it otherwise cannot tell it has. - * - *

    Spring Boot decides by asking for the console, and an image answers that it has none even - * when it is being watched at a terminal. So the same application whose start-up is coloured - * under {@code bootRun} arrives plain once it is built, for a reason that has nothing to do with - * the terminal it is running at.

    - * - *

    What the environment names as the terminal is read instead, which an image does carry. - * That does not distinguish output being watched from output being redirected -- nothing in an - * image does, which is the whole difficulty -- so a shell that redirects to a file still gets - * the escapes. It does distinguish a shell from the places that name no terminal at all: a - * build, a container, a service manager, where the output is only ever read later and stays - * plain. An application that has said either way is left alone.

    - */ - private void colourTheOutputOfAnImageThatHasATerminal(ConfigurableEnvironment environment) { - if (!isImage() || environment.containsProperty(ANSI_ENABLED)) { - return; - } - String terminal = terminal(); - if (terminal == null || terminal.isEmpty() || "dumb".equals(terminal)) { - return; - } - environment.getPropertySources().addLast(new MapPropertySource("grails.ansi.output", - Map.of(ANSI_ENABLED, "always"))); - } - - /** Whether this is running as an image, which only a run can answer. */ - protected boolean isImage() { - return System.getProperty(IMAGE_CODE) != null; - } - - /** What the environment names as the terminal, if it names one. */ - protected String terminal() { - return System.getenv("TERM"); - } - /** * Loads plugin configuration files ({@code plugin.yml} or {@code plugin.groovy}) * in the topologically sorted order and adds them to the environment's property sources. diff --git a/grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java b/grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java index e949166e11c..ead6b03029c 100644 --- a/grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java +++ b/grails-core/src/main/groovy/org/apache/grails/core/aot/VarargsBeanRegistrationAotProcessor.java @@ -24,6 +24,8 @@ import java.util.List; import java.util.function.Predicate; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; import org.jspecify.annotations.Nullable; import org.springframework.aot.generate.GenerationContext; @@ -65,6 +67,8 @@ */ public class VarargsBeanRegistrationAotProcessor implements BeanRegistrationAotProcessor { + private static final Log logger = LogFactory.getLog(VarargsBeanRegistrationAotProcessor.class); + @Override @Nullable public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) { @@ -87,14 +91,23 @@ public BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registe * *

    Resolution reads the bean class and its members, so a bean whose class cannot be resolved * fails here rather than at the point of use. It is not this processor's place to report that: - * generation carries on and fails where it means something.

    + * generation carries on and fails where it means something, and a line is left behind so that + * a bean which is genuinely broken can be traced to here rather than only to what followed.

    + * + *

    An {@code Error} is not caught. This says only that a bean has no variable-argument + * constructor to gather, and a JVM that is out of memory or a class that will not link is + * neither that nor something to carry on generating through.

    */ @Nullable private Executable resolveExecutable(RegisteredBean registeredBean) { try { return registeredBean.resolveConstructorOrFactoryMethod(); } - catch (Throwable ignored) { + catch (Exception ex) { + if (logger.isDebugEnabled()) { + logger.debug("Not gathering arguments for bean '" + registeredBean.getBeanName() + + "', whose constructor could not be resolved", ex); + } return null; } } diff --git a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy index 6640184ac9a..af10847bade 100644 --- a/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy +++ b/grails-core/src/test/groovy/grails/boot/GrailsBannerNativeMarkSpec.groovy @@ -195,12 +195,20 @@ class GrailsBannerNativeMarkSpec extends Specification { GrailsBanner.OptionalVersionOption.values()*.key == ['tomcat', 'jetty', 'undertow'] } - void 'a library that is not there is left out rather than shown as unknown'() { - expect: 'jetty and undertow are not on this classpath; asking for them says nothing' + void 'a version asked for by name that cannot be determined is shown as unknown'() { + expect: 'jetty and undertow are not on this classpath, and saying nothing about a version ' + + 'that was asked for by name reads as the option having been ignored' configured(['grails.banner.versions.include': 'jetty,undertow']) String output = plain(new StartedAs()) - !output.contains('Jetty') - !output.contains('Undertow') + output.contains('Jetty: unknown') + output.contains('Undertow: unknown') + } + + void 'a version shown by default that cannot be determined is left out'() { + expect: 'which is what lets one be shown by default at all -- an application without Spring ' + + 'Security says nothing about it rather than saying it does not know' + configured([:]) + !plain(new StartedAs()).contains('Spring Security') } void 'an application can turn spring security off'() { diff --git a/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy b/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy deleted file mode 100644 index 97bedd9ac8d..00000000000 --- a/grails-core/src/test/groovy/grails/boot/config/GrailsEnvironmentPostProcessorAnsiSpec.groovy +++ /dev/null @@ -1,114 +0,0 @@ -/* - * 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 grails.boot.config - -import org.springframework.boot.bootstrap.BootstrapRegistry.InstanceSupplier -import org.springframework.boot.bootstrap.DefaultBootstrapContext -import org.springframework.core.env.MapPropertySource -import org.springframework.core.env.StandardEnvironment -import spock.lang.Specification - -import org.apache.grails.core.plugins.DefaultPluginDiscovery -import org.apache.grails.core.plugins.PluginDiscovery - -/** - * Covers an image colouring its output when it is being watched at a terminal. - * - *

    Spring Boot decides by asking for the console, and an image answers that it has none even when - * it has one -- so the same application whose start-up is coloured under bootRun arrives plain once - * it is built. What the environment names as the terminal is read instead, which an image does - * carry. It cannot tell output being watched from output being redirected -- nothing in an image - * can -- but it does tell a shell from a build, a container or a service manager.

    - */ -class GrailsEnvironmentPostProcessorAnsiSpec extends Specification { - - private static final String ANSI = 'spring.output.ansi.enabled' - - StandardEnvironment environment = new StandardEnvironment() - - /** - * Runs the post-processor the way Spring Boot runs it, rather than reaching past it for the one - * method under test: whether an image colours its output is only worth knowing about through the - * hook that decides it. - */ - private String ansiAfter(boolean image, String terminal) { - DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext() - bootstrapContext.register(PluginDiscovery, InstanceSupplier.of(noPlugins())) - new Processor(bootstrapContext, image, terminal).postProcessEnvironment(environment, null) - environment.getProperty(ANSI) - } - - /** Plugin discovery that finds none, so the phase this shares with completes and does nothing. */ - private static PluginDiscovery noPlugins() { - DefaultPluginDiscovery discovery = new DefaultPluginDiscovery(new Class[0]) - discovery.loadPluginsFromClasspath = false - discovery - } - - void 'an image at a terminal colours its output'() { - expect: - ansiAfter(true, 'xterm-256color') == 'always' - } - - void 'an image where nothing names a terminal stays plain'() { - expect: 'a build, a container or a service manager, whose output is only ever read later' - ansiAfter(true, null) == null - } - - void 'a terminal that cannot colour is left alone'() { - expect: - ansiAfter(true, 'dumb') == null - } - - void 'running on a JVM is left to Spring Boot'() { - expect: 'where asking for the console works, and answers for pipes too' - ansiAfter(false, 'xterm-256color') == null - } - - void 'an application that has said either way keeps what it said'() { - given: - environment.propertySources.addFirst(new MapPropertySource('test', [(ANSI): 'never'])) - - expect: - ansiAfter(true, 'xterm-256color') == 'never' - } - - /** Stands in for the two things only a run can answer. */ - static class Processor extends GrailsEnvironmentPostProcessor { - - private final boolean image - private final String terminal - - Processor(DefaultBootstrapContext bootstrapContext, boolean image, String terminal) { - super(bootstrapContext) - this.image = image - this.terminal = terminal - } - - @Override - protected boolean isImage() { - image - } - - @Override - protected String terminal() { - terminal - } - } -} diff --git a/grails-doc/src/en/guide/introduction/whatsNew.adoc b/grails-doc/src/en/guide/introduction/whatsNew.adoc index 3481d2f719a..d2f6d9b94ee 100644 --- a/grails-doc/src/en/guide/introduction/whatsNew.adoc +++ b/grails-doc/src/en/guide/introduction/whatsNew.adoc @@ -332,8 +332,10 @@ started where that is worth saying — `NATIVE` for an image, `AOT CACHE` for a running generated bean definitions. An ordinary start says nothing. Spring Security and the servlet container are also shown by default now. What allows that is a smaller change -underneath: a version that cannot be determined is left out of the banner rather than shown as `unknown`, so an -application without Spring Security says nothing about it instead of saying it does not know. See +underneath: a version shown by default that cannot be determined is left out rather than shown as `unknown`, so +an application without Spring Security says nothing about it instead of saying it does not know. One asked for +by name still reads `unknown`, because saying nothing about what was asked for reads as the option having been +ignored. See xref:conf/applicationClass/customizing[Customizing the Application Class] for the full set of banner options, and the xref:upgrading#upgrading80x[upgrade guide] for how to restore the previous output. diff --git a/grails-doc/src/en/guide/upgrading/upgrading80x.adoc b/grails-doc/src/en/guide/upgrading/upgrading80x.adoc index ab95bfefd4d..5fe1e312855 100644 --- a/grails-doc/src/en/guide/upgrading/upgrading80x.adoc +++ b/grails-doc/src/en/guide/upgrading/upgrading80x.adoc @@ -2263,10 +2263,10 @@ application has it, without being asked for either. Both were previously opt-in `grails.banner.versions.include`. What made them opt-in was that a version which could not be determined was shown as `unknown`, so turning one -on by default would have printed `Spring Security: unknown` for every application without it. A version that -cannot be determined is now left out of the banner entirely, which is what allows the two to be shown by -default — and which also means a version explicitly asked for, but not resolvable, no longer appears as -`unknown`. It appears not at all. +on by default would have printed `Spring Security: unknown` for every application without it. A version shown +by default that cannot be determined is now left out instead, which is what allows the two to be shown at all. +A version the application asked for by name still reads `unknown` where it cannot be determined, since saying +nothing about something that was asked for reads as the option having been ignored. The container is named as itself: an application on Tomcat shows `Tomcat`, one on Jetty shows `Jetty`. It is configured under the single key `container`, whichever container that turns out to be. From 67abf890b7ebadb1b632579e789bcf0c9e86386b Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 14 Aug 2026 00:25:39 -0700 Subject: [PATCH 098/115] Reach the archive and the assets without resolving them early extractAotCacheApplication was an Exec that deleted through the project and built its command line in doFirst, which is Project access at execution time and a hard error under the configuration cache. It is a task type now, with the archive as an input, the extracted application as an output, and the deleting and running done through injected FileSystemOperations and ExecOperations. archiveOf resolved the bootJar task to read its archive, so every build that merely configured this project paid for resolving it. It is a Provider now, which the trace and training tasks take as well. The assets are attached to bootJar through a file collection that matches the task by name rather than through afterEvaluate and findByName. The asset pipeline's plugin id has changed once already and its task name has not, so matching by name is what stays true -- while nothing is resolved to find out whether it is there. The precompiled page manifest is attached only where those are the pages that will be rendered: a deployed application, and one whose code is being written out. A manifest left on the classpath by an earlier build, or shipped inside a plugin, no longer stops a page being reloaded as it is edited in a project on disk. Covered both ways by a spec. --- .../plugin/aot/ExtractApplicationTask.groovy | 88 +++++++++++++++++++ .../plugin/core/GrailsGradlePlugin.groovy | 63 ++++++------- .../web/GroovyPagesGrailsPlugin.groovy | 25 +++--- ...ovyPagesGrailsPluginPrecompiledSpec.groovy | 77 ++++++++++++++++ 4 files changed, 207 insertions(+), 46 deletions(-) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy create mode 100644 grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/GroovyPagesGrailsPluginPrecompiledSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy new file mode 100644 index 00000000000..f10c4fe0d0d --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy @@ -0,0 +1,88 @@ +/* + * 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.grails.gradle.plugin.aot + +import javax.inject.Inject + +import groovy.transform.CompileStatic +import org.gradle.api.DefaultTask +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.file.FileSystemOperations +import org.gradle.api.file.RegularFileProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.CacheableTask +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputFile +import org.gradle.api.tasks.OutputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction +import org.gradle.process.ExecOperations + +/** + * Unpacks an executable jar into the form an AOT cache is read against. + * + *

    An executable jar loads its dependencies through a nested-jar class loader; the extracted form + * loads them as ordinary jars on the classpath. A cache records the class path it saw, so only the + * second is a layout a later run can reuse one against.

    + * + *

    The work is done through injected services rather than through the project, so that nothing is + * reached at execution time that the configuration cache forbids.

    + * + * @since 8.0 + */ +@CacheableTask +@CompileStatic +abstract class ExtractApplicationTask extends DefaultTask { + + /** The archive to unpack, which has to be the one the cache will be trained against. */ + @InputFile + @PathSensitive(PathSensitivity.RELATIVE) + abstract RegularFileProperty getArchiveFile() + + /** + * The java to unpack with. Its {@code jarmode} does the extracting, so it is the JDK the + * application was built for rather than whichever one is running Gradle. + */ + @Input + abstract Property getJavaExecutable() + + @OutputDirectory + abstract DirectoryProperty getDestination() + + @Inject + abstract FileSystemOperations getFileSystemOperations() + + @Inject + abstract ExecOperations getExecOperations() + + @TaskAction + void extract() { + File target = destination.get().asFile + // Emptied rather than deleted: it is this task's declared output, and what was left by a + // previous archive would otherwise be read as part of this one. + fileSystemOperations.delete { spec -> spec.delete(target) } + target.mkdirs() + execOperations.exec { spec -> + spec.commandLine(javaExecutable.get(), '-Djarmode=tools', '-jar', + archiveFile.get().asFile.absolutePath, 'extract', + '--destination', target.absolutePath) + } + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 59d76e038e3..47faf015ac8 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -52,7 +52,6 @@ import org.gradle.api.plugins.ExtraPropertiesExtension import org.gradle.api.plugins.GroovyPlugin import org.gradle.api.plugins.JavaPluginExtension import org.gradle.api.provider.Provider -import org.gradle.api.tasks.Exec import org.gradle.api.tasks.AbstractCopyTask import org.gradle.api.tasks.JavaExec import org.gradle.api.tasks.SourceSet @@ -71,6 +70,7 @@ import org.grails.gradle.plugin.exploded.ExplodedCompatibilityRule import org.grails.gradle.plugin.exploded.ExplodedDisambiguationRule import org.grails.gradle.plugin.exploded.GrailsExplodedPlugin import org.grails.gradle.plugin.aot.AotCacheExtension +import org.grails.gradle.plugin.aot.ExtractApplicationTask import org.grails.gradle.plugin.aot.GenerateNativeMetadataTask import org.grails.gradle.plugin.aot.NativeMetadataExtension import org.grails.gradle.plugin.aot.TraceNativeMetadataTask @@ -887,18 +887,15 @@ ${importStatements} */ private void configureAssetsOnTheClasspath(Project project) { project.pluginManager.withPlugin(SPRING_BOOT_PLUGIN) { - // Read after the build script has run, and by the task the pipeline registers rather - // than by the plugin that registers it: the asset pipeline's plugin id has changed - // once already, and the task name has not. - project.afterEvaluate { - Task assetCompile = project.tasks.findByName(ASSET_COMPILE_TASK) - if (assetCompile == null) { - return - } - project.tasks.named('bootJar', AbstractCopyTask).configure { AbstractCopyTask task -> - task.from(assetCompile.outputs.files) { CopySpec spec -> - spec.into(CLASSPATH_ASSETS_PATH) - } + // Matched by the task the pipeline registers rather than by the plugin that registers + // it: the asset pipeline's plugin id has changed once already, and the task name has + // not. Matched rather than looked up, so nothing depends on which plugin was applied + // first and no task is resolved to find out. + FileCollection compiledAssets = project.files( + project.tasks.matching { Task task -> task.name == ASSET_COMPILE_TASK }) + project.tasks.named('bootJar', AbstractCopyTask).configure { AbstractCopyTask task -> + task.from(compiledAssets) { CopySpec spec -> + spec.into(CLASSPATH_ASSETS_PATH) } } } @@ -1024,7 +1021,7 @@ ${importStatements} task.group = BasePlugin.BUILD_GROUP task.description = 'Runs the application under the tracing agent and records the reflection it does' task.dependsOn(bootJar) - task.archiveFile.set(project.provider { project.layout.projectDirectory.file(archiveOf(bootJar).absolutePath) }) + task.archiveFile.set(archiveFileOf(bootJar)) // The project's toolchain unless told otherwise, which for a project that builds an // image is the GraalVM the image is built with -- and the agent is only there. task.javaExecutable.set(extension.javaExecutable @@ -1291,25 +1288,16 @@ ${importStatements} Provider application = project.layout.buildDirectory.dir('aot-cache/application') Provider launcher = trainingLauncher(project) - TaskProvider extract = project.tasks.register('extractAotCacheApplication', Exec) { Exec task -> + TaskProvider extract = project.tasks.register( + 'extractAotCacheApplication', ExtractApplicationTask) { ExtractApplicationTask task -> task.group = BasePlugin.BUILD_GROUP task.description = 'Extracts the application, which is the form the cache is read against' task.onlyIf { extension.enabled.get() } - task.dependsOn(bootJar) - // Named so the extraction is skipped when the archive it came from has not moved, - // rather than repeated on every run because nothing said what it produced. - task.inputs.file(project.provider { archiveOf(bootJar) }) - task.outputs.dir(application) - task.doFirst { - File destination = application.get().asFile - project.delete(destination) - destination.mkdirs() - // Set here rather than while the build is configured, so the JDK the toolchain - // resolves to is not provisioned by every build that merely reads this project. - task.commandLine(launcher.get().executablePath.asFile.absolutePath, - '-Djarmode=tools', '-jar', archiveOf(bootJar).absolutePath, 'extract', - '--destination', destination.absolutePath) - } + task.archiveFile.set(archiveFileOf(bootJar)) + // Mapped rather than read, so the JDK the toolchain resolves to is not provisioned + // by every build that merely reads this project. + task.javaExecutable.set(launcher.map { JavaLauncher java -> java.executablePath.asFile.absolutePath }) + task.destination.set(application) } project.tasks.register('trainAotCache', TrainAotCacheTask) { TrainAotCacheTask task -> @@ -1318,7 +1306,7 @@ ${importStatements} task.onlyIf { extension.enabled.get() } task.dependsOn(extract) task.applicationDirectory.set(application) - task.archiveFileName.set(project.provider { archiveOf(bootJar).name }) + task.archiveFileName.set(archiveFileOf(bootJar).map { RegularFile file -> file.asFile.name }) // Beside the extracted application rather than inside it. Inside, the cache and its // metadata land in the directory this task declares as its input, so writing them // changes that input and the task can never be up to date -- every build would run @@ -1340,10 +1328,15 @@ ${importStatements} } } - /** The archive to extract, read when the task runs rather than while the build is configured. */ - private static File archiveOf(TaskProvider bootJar) { - Provider archive = (Provider) bootJar.get().property('archiveFile') - archive.get().asFile + /** + * The archive a task should consume, as something to be resolved when it runs. + * + *

    A provider rather than a file: asking the task for its archive resolves the task, and a + * task resolved while the build is configured is one every build pays for whether or not it + * asked for an archive.

    + */ + private static Provider archiveFileOf(TaskProvider bootJar) { + bootJar.flatMap { Task task -> (Provider) task.property('archiveFile') } } /** diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index c7e24dedc41..6011ac2ae9f 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -191,17 +191,20 @@ class GroovyPagesGrailsPlugin extends Plugin { if (customResourceLoader) { resourceLoader = groovyPageResourceLoader } - // Where the pages compiled at build time are listed. Attached whatever the - // surroundings, because whether to read from it is decided where a page is looked - // up, at run time, and only there is the answer knowable: deciding it here settles - // it while the definition is being generated, in the directory the application was - // built in, where a development environment is available -- so an image would be - // built believing it has to compile its pages, which is the one thing it cannot do. - // Named rather than resolved, so that what is written down is a location to look in - // and not a path on the machine that did the building. - precompiledGspMap = { PropertiesFactoryBean pfb -> - ignoreResourceNotFound = true - locations = ['gsp/views.properties', 'classpath:gsp/views.properties'] + // Where the pages compiled at build time are listed, attached anywhere they are + // the pages that will be rendered: a deployed application, and one whose code is + // being written out. isDevelopmentMode() answers no to the second, so an image is + // not built believing it has to compile its pages -- which is the one thing it + // cannot do -- while a project on disk still reads its pages from source and + // recompiles them as they are edited. + // + // The locations are named rather than resolved here, so what is written down is + // somewhere to look and not a path on the machine that did the building. + if (!developmentMode) { + precompiledGspMap = { PropertiesFactoryBean pfb -> + ignoreResourceNotFound = true + locations = ['gsp/views.properties', 'classpath:gsp/views.properties'] + } } if (enableReload) { cacheTimeout = gspCacheTimeout diff --git a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/GroovyPagesGrailsPluginPrecompiledSpec.groovy b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/GroovyPagesGrailsPluginPrecompiledSpec.groovy new file mode 100644 index 00000000000..a3df435722a --- /dev/null +++ b/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/GroovyPagesGrailsPluginPrecompiledSpec.groovy @@ -0,0 +1,77 @@ +/* + * 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.grails.plugins.web + +import org.springframework.beans.factory.support.AbstractBeanDefinition +import org.springframework.beans.factory.support.DefaultListableBeanFactory + +import grails.core.DefaultGrailsApplication +import grails.spring.BeanBuilder +import spock.lang.Specification + +/** + * Covers when the manifest of pages compiled at build time is attached to the page locator. + * + *

    Attached, the locator reads its pages from what was compiled. That is right for a deployed + * application and for one whose code is being written out -- an image cannot compile a page at all + * -- and wrong for a project on disk, where editing a page has to take effect without a restart. + * A manifest left on the classpath by an earlier build, or shipped inside a plugin, must not turn + * that off.

    + */ +class GroovyPagesGrailsPluginPrecompiledSpec extends Specification { + + private static final String LOCATOR = 'groovyPageLocator' + + private AbstractBeanDefinition locatorFrom(boolean developmentMode) { + def application = new DefaultGrailsApplication() + application.initialise() + def plugin = new Plugin(developmentMode: developmentMode, grailsApplication: application) + def beanFactory = new DefaultListableBeanFactory() + def builder = new BeanBuilder(null, null, getClass().classLoader) + builder.beans(plugin.doWithSpring()) + builder.registerBeans(beanFactory) + (AbstractBeanDefinition) beanFactory.getBeanDefinition(LOCATOR) + } + + private static boolean readsPrecompiledPages(AbstractBeanDefinition locator) { + locator.propertyValues.contains('precompiledGspMap') + } + + void 'a deployed application reads the pages compiled at build time'() { + expect: + readsPrecompiledPages(locatorFrom(false)) + } + + void 'a project on disk does not, whatever manifest is on its classpath'() { + expect: 'a manifest left by an earlier build, or shipped inside a plugin, would otherwise ' + + 'stop a page being reloaded as it is edited' + !readsPrecompiledPages(locatorFrom(true)) + } + + /** A plugin told what its surroundings are, which only a run can otherwise answer. */ + static class Plugin extends GroovyPagesGrailsPlugin { + + boolean developmentMode + + @Override + protected boolean isDevelopmentMode() { + developmentMode + } + } +} From b22be605696ec37a422bd0a962e70bd4c8657a23 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Fri, 14 Aug 2026 00:31:01 -0700 Subject: [PATCH 099/115] Say what the artefacts are read from, and check it holds classes() reads a singleton off the context, and whether the context is there when it is asked was left for the reader to work out. It is, on both paths that ask: the early registration phase sets it on the instance it creates, and the @Bean method is invoked after Spring has applied ApplicationContextAware. It has to be -- the scan beside it resolves resources through the context and did so before any of this was written -- so nothing new is being relied upon. Said in the javadoc now, and covered by a spec on classes() rather than on the method behind it. It reads the bean factory rather than getAutowireCapableBeanFactory(), which refuses a context that has not been refreshed. This is asked while definitions are still being contributed, which is the reason the classes are left as a singleton at all, so asking must not depend on how far the context has got. And a spec for the other end of the same question: a resource locator that inherited nowhere to look still finds a packaged resource, which is what makes emptying the inherited search locations safe rather than merely quiet. --- .../config/GrailsAutoConfiguration.groovy | 19 ++++- ...railsAutoConfigurationArtefactsSpec.groovy | 79 +++++++++++++++++++ ...actResourceLocatorPostProcessorSpec.groovy | 13 +++ 3 files changed, 108 insertions(+), 3 deletions(-) create mode 100644 grails-core/src/test/groovy/grails/boot/config/GrailsAutoConfigurationArtefactsSpec.groovy diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy b/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy index ebf0f8f7b26..5047aadb0a7 100644 --- a/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy +++ b/grails-core/src/main/groovy/grails/boot/config/GrailsAutoConfiguration.groovy @@ -25,9 +25,9 @@ import groovy.transform.CompileStatic import org.springframework.aop.config.AopConfigUtils import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationContextAware +import org.springframework.context.ConfigurableApplicationContext import org.springframework.context.annotation.Bean import org.springframework.aot.AotDetector -import org.springframework.beans.factory.config.SingletonBeanRegistry import org.springframework.core.io.support.PathMatchingResourcePatternResolver import grails.boot.config.tools.ClassPathScanner @@ -78,6 +78,15 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont } /** + * The classes that constitute the Grails application. + * + *

    The context is set before this is asked, on both paths that ask it: the early registration + * phase sets it on the instance it creates, and the {@code @Bean} method below is invoked on + * this configuration class after Spring has applied {@link ApplicationContextAware}. It has to + * be -- the scan below resolves its resources through the context, and did so before any of + * this was written -- so reading a singleton from it here adds no ordering that was not + * already relied upon.

    + * * @return The classes that constitute the Grails application */ Collection classes() { @@ -112,8 +121,12 @@ class GrailsAutoConfiguration implements GrailsApplicationClass, ApplicationCont if (applicationContext == null || !AotDetector.useGeneratedArtifacts()) { return null } - Object written = applicationContext.autowireCapableBeanFactory instanceof SingletonBeanRegistry - ? ((SingletonBeanRegistry) applicationContext.autowireCapableBeanFactory) + // Read from the bean factory rather than through getAutowireCapableBeanFactory(), which + // refuses a context that has not been refreshed. This is asked while the definitions are + // still being contributed, which is why the classes are left as a singleton in the first + // place, and asking must not depend on how far the context has got. + Object written = applicationContext instanceof ConfigurableApplicationContext + ? ((ConfigurableApplicationContext) applicationContext).beanFactory .getSingleton(ArtefactClassesBeanFactoryInitializationAotProcessor.BEAN_NAME) : null written instanceof Class[] ? Arrays.asList((Class[]) written) : null diff --git a/grails-core/src/test/groovy/grails/boot/config/GrailsAutoConfigurationArtefactsSpec.groovy b/grails-core/src/test/groovy/grails/boot/config/GrailsAutoConfigurationArtefactsSpec.groovy new file mode 100644 index 00000000000..045d2852e4b --- /dev/null +++ b/grails-core/src/test/groovy/grails/boot/config/GrailsAutoConfigurationArtefactsSpec.groovy @@ -0,0 +1,79 @@ +/* + * 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 grails.boot.config + +import org.springframework.aot.AotDetector +import org.springframework.context.support.GenericApplicationContext +import org.springframework.core.SpringProperties +import spock.lang.Specification + +import org.apache.grails.core.aot.ArtefactClassesBeanFactoryInitializationAotProcessor + +/** + * Covers an application reading back the artefacts written down while its code was generated. + * + *

    Both of the usual ways to find them need something an image does not have -- a classpath to + * walk, or a list the compile-time transform built as it went -- so what was found while the code + * was generated is registered as a singleton and read here.

    + */ +class GrailsAutoConfigurationArtefactsSpec extends Specification { + + GenericApplicationContext context = new GenericApplicationContext() + + void cleanup() { + SpringProperties.setProperty(AotDetector.AOT_ENABLED, null) + context.close() + } + + /** Registered the way the generated initializer registers it, before any definition is read. */ + private void written(Class... artefacts) { + context.beanFactory.registerSingleton( + ArtefactClassesBeanFactoryInitializationAotProcessor.BEAN_NAME, artefacts) + } + + private GrailsAutoConfiguration application() { + new GrailsAutoConfiguration(applicationContext: context) + } + + void 'the artefacts written down are what the application is made of'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'true') + written(String, Integer) + + expect: 'rather than a scan, which in an image finds nothing at all' + application().classes() == [String, Integer] + } + + void 'nothing written down leaves them to be found the usual ways'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'true') + + expect: 'a context generated before this was written has no such singleton' + application().classes() != null + } + + void 'an ordinary start does not read them even where they are there'() { + given: + SpringProperties.setProperty(AotDetector.AOT_ENABLED, 'false') + written(String, Integer) + + expect: 'the scan is the answer wherever scanning works, and stays the answer' + application().classes() != [String, Integer] + } +} diff --git a/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy b/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy index de2e1d2dd73..3eca79f16b4 100644 --- a/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy +++ b/grails-core/src/test/groovy/org/grails/spring/beans/AbstractResourceLocatorPostProcessorSpec.groovy @@ -22,6 +22,8 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry import org.springframework.beans.factory.support.DefaultListableBeanFactory import org.springframework.beans.factory.support.RootBeanDefinition import org.springframework.context.aot.AbstractAotProcessor +import org.grails.core.io.DefaultResourceLocator +import org.springframework.core.io.DefaultResourceLoader import spock.lang.Specification /** @@ -93,4 +95,15 @@ class AbstractResourceLocatorPostProcessorSpec extends Specification { then: 'which is how an application overrides where its resources are looked for' registry.getBeanDefinition(AbstractResourceLocatorPostProcessor.BEAN_NAME).is(existing) } + + void 'a locator inheriting nowhere to look still finds a packaged resource'() { + given: 'what a child inherits from the template while the code is being written out' + DefaultResourceLocator locator = new DefaultResourceLocator() + locator.setResourceLoader(new DefaultResourceLoader()) + locator.setSearchLocations([]) + + expect: 'the directories are somewhere to look on the machine that built it, and what is ' + + 'left when there are none is the application reading its own contents' + locator.findResourceForURI('classpath:grails-banner.txt')?.exists() + } } From 6d4bb566bf816864dabb0b6cc022cc26fddd9491 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:31:06 -0700 Subject: [PATCH 100/115] Give the training run the archive by its full path A cache records the classpath it was trained against. The run was given the archive by file name, so what it wrote down was a bare name, and a bare name is resolved against the working directory of whatever starts the application later. The cache was therefore usable only from the extracted directory. Started any other way -- `java -jar /opt/app/app.jar` from a service unit, or an image whose working directory is not the one the archive sits in -- the JVM reports Required classpath entry does not exist: app.jar ignores the cache and starts as it would have anyway, so the deployment quietly loses the startup time the cache exists to save. Measured on a demo application, 1201 ms from the extracted directory against 2509 ms from anywhere else. An absolute entry is matched by prefix substitution instead, which survives both a different working directory and the directory being moved -- the latter being what deploying it does. The run is still made in the application directory, so the archive still finds what sits beside it. --- .../guide/deployment/deploymentAotCache.adoc | 14 ++++-- .../plugin/aot/TrainAotCacheTask.groovy | 9 +++- .../plugin/aot/TrainAotCacheTaskSpec.groovy | 46 +++++++++++++++++++ 3 files changed, 65 insertions(+), 4 deletions(-) diff --git a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc index 29180c51427..e30532c8ce8 100644 --- a/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc +++ b/grails-doc/src/en/guide/deployment/deploymentAotCache.adoc @@ -74,14 +74,22 @@ build/aot-cache/ [source,bash] ---- -cd build/aot-cache/application -java -XX:AOTCache=../myapp.aot -Dspring.aot.enabled=true -Dgrails.env=production -jar myapp.jar +java -XX:AOTCache=build/aot-cache/myapp.aot -Dspring.aot.enabled=true -Dgrails.env=production \ + -jar build/aot-cache/application/myapp.jar ---- -Run it from the extracted directory, as the training run was run: a cache records the classpath it saw, and reaching the same jar by a different path is a different classpath. +It does not matter which directory it is started from. Moving the whole of `aot-cache` elsewhere is fine too — a container image that unpacks it under `/opt` is the usual case — as long as the cache and `application/` move together and keep their timestamps, which the cache checks the archive against. Copying only the jar out of `application/` does not work, and not because of the cache: the extracted layout reaches its dependencies through `lib/` beside it. A JVM given a cache it cannot use does not fail. It reports why, ignores the cache, and starts as it would have anyway — so an invalid cache costs the startup time it was meant to save, silently, and without any other symptom. +Adding `-XX:AOTMode=on` turns that into a failure to start, which is worth doing wherever the cache is the reason the deployment meets its startup time. A cache that has been invalidated then stops the process rather than quietly making it slower: + +[source] +---- +[0.003s][warning][aot] Unable to use AOT cache. +[0.003s][error ][aot] Loading static archive failed. +---- + === What the training run should do diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index 90bbd0ed5bb..f2d005199e1 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -116,7 +116,14 @@ abstract class TrainAotCacheTask extends DefaultTask { command << javaExecutable.get() command << "-XX:AOTCacheOutput=${cache.absolutePath}".toString() command.addAll(jvmArguments.get()) - command << '-jar' << archiveFileName.get() + // Named in full rather than left to the working directory to resolve. The cache records the + // classpath it was trained against, and a relative entry is resolved against the working + // directory of whatever starts the application later -- so a cache trained by name is + // refused for `java -jar /opt/app/app.jar`, which is what a service unit and a container + // both do. The application still gets that directory to run in; it is only what the cache + // wrote down that changes. An absolute entry is matched by prefix substitution instead, + // which survives the directory being moved as well as being started from somewhere else. + command << '-jar' << new File(directory, archiveFileName.get()).absolutePath command << "--server.port=${port.get()}".toString() File output = new File(temporaryDir, 'training.log') diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index 35a68516fb6..642fd89377c 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -162,6 +162,52 @@ exit 1 seen.readLines().any { String line -> line.startsWith('PATH=') } } + void 'the run is given the archive by its full path, and still runs in its directory'() { + given: 'a run that writes down where it was put and what it was given, and ends' + File application = new File(temporaryFolder, 'named') + application.mkdirs() + new File(application, 'named.jar').text = 'stands in for the archive' + File arguments = new File(temporaryFolder, 'seen-arguments.txt') + File directory = new File(temporaryFolder, 'seen-directory.txt') + File script = new File(temporaryFolder, 'recording-jvm.sh') + script.text = """#!/bin/sh +pwd -P > '${directory.absolutePath}' +for argument in "\$@"; do echo "\$argument" >> '${arguments.absolutePath}'; done +exit 1 +""" + script.setExecutable(true) + TrainAotCacheTask task = project.tasks.create('trainNamed', TrainAotCacheTask) + task.applicationDirectory.set(application) + task.archiveFileName.set('named.jar') + task.cacheFile.set(new File(application, 'demo.aot')) + task.metadataFile.set(new File(application, 'aot-cache.properties')) + task.javaExecutable.set(script.absolutePath) + task.javaVersion.set('25.0.1+9') + task.javaVendor.set('A Vendor') + task.jvmArguments.set([]) + task.paths.set([]) + task.port.set(18095) + task.startTimeoutSeconds.set(5) + + when: + task.train() + + then: + thrown(GradleException) + + and: 'the cache records the classpath it was trained against, and an entry that is a bare ' + + 'name is resolved against the working directory of whatever starts the application ' + + 'later -- so a cache trained by name is refused for java -jar /opt/app/app.jar' + List given = arguments.readLines() + int jar = given.indexOf('-jar') + jar >= 0 + given[jar + 1] == new File(application, 'named.jar').absolutePath + + and: 'while the run itself is still made in the application directory, which is where the ' + + 'archive expects to find what sits beside it' + directory.text.trim() == application.canonicalPath + } + void 'a run that never starts serving fails the build'() { given: 'an archive that is not one, so the run ends immediately' TrainAotCacheTask task = task('not-an-archive.jar', []) From 0021e820a585526ff33b639485740a131f4bc343 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:43:22 -0700 Subject: [PATCH 101/115] Keep the project out of what the AOT tasks carry Two configuration-time slips in the same method. The cache file name was built inside a provider closure that read project.name. A provider is queried when the property is finalized or the task runs, so the closure carried the Project into the task's state, which the configuration cache refuses. This repo sets org.gradle.configuration-cache=false, so CI would not have caught it; a consumer building with it on would. And whether compileGroovy and copyAstClasses exist was asked with findByName, which creates the task in order to answer -- so a build paid for tasks it may not have depended on. The names answer the same question without realizing anything. --- .../gradle/plugin/core/GrailsGradlePlugin.groovy | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 47faf015ac8..5f9f55c2f18 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -1312,7 +1312,12 @@ ${importStatements} // changes that input and the task can never be up to date -- every build would run // the application again to record what the last one already recorded. Provider beside = project.layout.buildDirectory.dir('aot-cache') - task.cacheFile.set(beside.map { Directory dir -> dir.file("${project.name}.aot") }) + // Read here rather than inside the closure below. A provider is queried when the + // property is finalized or the task runs, so a closure that reaches through + // project carries the project into the task's state -- which the configuration + // cache refuses. The name is a string by then, which it does not mind. + String cacheName = project.name + task.cacheFile.set(beside.map { Directory dir -> dir.file("${cacheName}.aot") }) task.metadataFile.set(beside.map { Directory dir -> dir.file('aot-cache.properties') }) task.javaExecutable.set(launcher.map { JavaLauncher java -> java.executablePath.asFile.absolutePath }) // Recorded from the JDK that will run the training, not the one running the build. @@ -1383,8 +1388,10 @@ ${importStatements} // stated. It is stated against the compilation rather than the classes task, because // the classes task also runs processResources, which consumes this task's output. task.dependsOn(project.tasks.named(sourceSet.compileJavaTaskName)) + // Asked of the names rather than of the tasks: findByName creates the task in order to + // answer whether it exists, so a build pays for one it may not have depended on. ['compileGroovy', 'copyAstClasses'].each { String name -> - if (project.tasks.findByName(name)) { + if (project.tasks.names.contains(name)) { task.dependsOn(project.tasks.named(name)) } } From 03638e7424b8b55ff7d4aeb03bd5d2e8cfdcda33 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:43:22 -0700 Subject: [PATCH 102/115] Wait for the application to start, not for the word "Started" Both the training run and the trace waited on contains('Started '), which a container satisfies long before the application is ready: Jetty logs "Started ServerConnector@..." and "Started Server@..." while the context is still being built. A run taken for started there is trained or traced half built, and what it records is quietly thinner than it should be -- a slower start, or a class missing from an image, rather than anything that failed. Spring Boot's line has a shape no container's does -- a name, "in", and a number of seconds -- and that is what is now matched. The same read was taking the whole log every 250ms in the platform default charset. StartupLog reads what has been added since it last looked, as UTF-8, and matches whole lines so one still being written is left for the next look rather than cut in half and missed. --- .../gradle/plugin/aot/StartupLog.groovy | 113 +++++++++++++++ .../plugin/aot/TrainAotCacheTask.groovy | 3 +- .../gradle/plugin/aot/StartupLogSpec.groovy | 129 ++++++++++++++++++ 3 files changed, 244 insertions(+), 1 deletion(-) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy new file mode 100644 index 00000000000..633a6dbf1b2 --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy @@ -0,0 +1,113 @@ +/* + * 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.grails.gradle.plugin.aot + +import groovy.transform.CompileStatic + +import java.nio.charset.StandardCharsets +import java.util.regex.Pattern + +/** + * What a starting application prints, read as it is written. + * + *

    Asked whether the application has finished starting, rather than whether the word "Started" + * has appeared. A container prints that word well before the application is ready -- Jetty logs + * {@code Started ServerConnector@...} and {@code Started Server@...} while the context is still + * being built -- and a run taken for started there is trained or traced half-built. What is + * recorded is then quietly thinner than it should be, which is the kind of thing that shows up as a + * slower start or a missing class in an image rather than as anything that failed.

    + * + *

    Spring Boot's own line has a shape no container's does: a name, {@code in}, and a number of + * seconds. That is what is matched.

    + * + *

    Only what has been added since the last look is read, and it is read as UTF-8 rather than as + * whatever the machine's default happens to be. Matching is on whole lines, so a line still being + * written is left for the next look rather than being cut in half and missed.

    + */ +@CompileStatic +final class StartupLog { + + /** Spring Boot's, e.g. {@code Started Application in 2.597 seconds (process running for 3.068)}. */ + private static final Pattern STARTED = Pattern.compile(/Started .+ in [\d.]+ seconds/) + + private static final int MOST_READ_AT_ONCE = 1 << 20 + + private final File file + + /** How far into the file has already been read, so a poll costs the new bytes rather than all. */ + private long position + + /** What was read but is not yet a whole line. */ + private final StringBuilder pending = new StringBuilder() + + private boolean started + + StartupLog(File file) { + this.file = file + } + + /** + * Whether the application has said it finished starting. + * + *

    Answered from what has been written so far, so it is asked repeatedly while waiting.

    + */ + boolean saysItStarted() { + if (started) { + return true + } + if (!file.isFile()) { + return false + } + read() + int newline + while ((newline = pending.indexOf('\n')) >= 0) { + String line = pending.substring(0, newline) + pending.delete(0, newline + 1) + if (STARTED.matcher(line).find()) { + started = true + return true + } + } + false + } + + private void read() { + long length = file.length() + // A file that shrank is one that was replaced, so start again rather than read from the + // middle of it. + if (length < position) { + position = 0 + pending.setLength(0) + } + while (length > position) { + int wanted = (int) Math.min(length - position, MOST_READ_AT_ONCE as long) + byte[] bytes = new byte[wanted] + int read = 0 + new RandomAccessFile(file, 'r').withCloseable { RandomAccessFile open -> + open.seek(position) + read = open.read(bytes) + } + if (read <= 0) { + return + } + pending.append(new String(bytes, 0, read, StandardCharsets.UTF_8)) + position += read + } + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index f2d005199e1..1302bc1bc68 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -273,12 +273,13 @@ abstract class TrainAotCacheTask extends DefaultTask { */ private void awaitStarted(Process process, File output) { long deadline = System.currentTimeMillis() + Duration.ofSeconds(startTimeoutSeconds.get()).toMillis() + StartupLog log = new StartupLog(output) while (System.currentTimeMillis() < deadline) { if (!process.isAlive()) { throw new GradleException('The training run ended before it started serving.' + whyItEnded(output) + " What it printed is in ${output}") } - if (output.isFile() && output.text.contains('Started ')) { + if (log.saysItStarted()) { return } if (serving()) { diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy new file mode 100644 index 00000000000..0223e45f4f8 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy @@ -0,0 +1,129 @@ +/* + * 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.grails.gradle.plugin.aot + +import spock.lang.Specification +import spock.lang.TempDir + +import java.nio.charset.StandardCharsets + +/** + * Covers telling an application that has started from a container that has started something. + */ +class StartupLogSpec extends Specification { + + @TempDir + File temporaryFolder + + private File log + + private StartupLog startupLog() { + log = new File(temporaryFolder, 'run.log') + new StartupLog(log) + } + + private void append(String text) { + log.append(text, 'UTF-8') + } + + void 'a log that does not exist yet has not started'() { + expect: + !startupLog().saysItStarted() + } + + void 'what a container prints while it is still coming up is not the application starting'() { + given: 'the lines Jetty prints before the context is built' + StartupLog started = startupLog() + append('''\ +Started ServerConnector@6d4b1c02{HTTP/1.1, (http/1.1)}{0.0.0.0:8080} +Started Server@1f2a3b4c{STARTING}[12.0.0] +''') + + expect: 'trained or traced here, what is recorded is a half-built application' + !started.saysItStarted() + } + + void 'the line Spring Boot prints when it has finished starting is'() { + given: + StartupLog started = startupLog() + append('Started Application in 2.597 seconds (process running for 3.068)\n') + + expect: + started.saysItStarted() + } + + void 'a line still being written is left rather than cut in half and missed'() { + given: 'the log read while the line is half written, as polling it will do' + StartupLog started = startupLog() + append('Started Applicat') + + expect: 'no answer is given for a line that is not finished' + !started.saysItStarted() + + when: 'the rest of it arrives' + append('ion in 2.597 seconds (process running for 3.068)\n') + + then: 'it is read as the one line it is, rather than as the two reads it arrived in' + started.saysItStarted() + } + + void 'once it has started it stays started'() { + given: + StartupLog started = startupLog() + append('Started Application in 1.0 seconds\n') + + expect: + started.saysItStarted() + + when: 'the file is truncated, as a rerun into the same log would' + log.text = '' + + then: 'the run that already said it started is not un-started by it' + started.saysItStarted() + } + + void 'the log is read as UTF-8 rather than as whatever the machine defaults to'() { + given: 'a log with a name outside ASCII before the line that matters' + StartupLog started = startupLog() + log.newOutputStream().withCloseable { OutputStream out -> + out.write('Ignorer les caractères accentués — ça arrive\n'.getBytes(StandardCharsets.UTF_8)) + out.write('Started Applicatión in 2.5 seconds\n'.getBytes(StandardCharsets.UTF_8)) + } + + expect: + started.saysItStarted() + } + + void 'a word that is only the container announcing a port never satisfies it'() { + given: + StartupLog started = startupLog() + append(line + '\n') + + expect: + started.saysItStarted() == counts + + where: + line || counts + 'Started ServerConnector@1{HTTP/1.1}{0.0.0.0:8080}' || false + 'Tomcat started on port 8080 (http) with context path \'/\'' || false + 'Started Server@2{STARTING}[12.0.0]' || false + 'Started Application in 2.597 seconds' || true + 'Started MyApp in 12.5 seconds (process running for 13.1)' || true + } +} From cb76065a1e6124bef595dfac10b97c147c7ce444 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:43:22 -0700 Subject: [PATCH 103/115] Close the client the trace ran with HttpClient owns a selector thread and an executor, and the daemon outlives the build -- so a client left open is a set of threads left running, and another set for every later build that traces again. Its javadoc claimed nothing was left behind in the daemon, which was the thing that happened. --- .../plugin/aot/TraceNativeMetadataTask.groovy | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index b23b933ae2f..8f6c58e1ca7 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -114,8 +114,12 @@ abstract class TraceNativeMetadataTask extends DefaultTask { * Carries the session from one request to the next, which is what makes a form that * authenticates worth submitting: the pages that follow it are only reachable once it has been. * - *

    Its own cookie store rather than the JVM's. The store belongs to the client, so nothing is - * left behind in a daemon that outlives the build and two traces at once cannot share one.

    + *

    Its own cookie store rather than the JVM's, so two traces at once cannot share a session + * and none of it is global to the daemon.

    + * + *

    Built for the run and closed when it ends. The client owns a selector thread and an + * executor, which do not stop being owned when the build does -- so it is closed rather than + * left for the daemon to carry until it exits.

    */ private HttpClient client @@ -195,6 +199,11 @@ abstract class TraceNativeMetadataTask extends DefaultTask { } finally { stop(process) + // Closed with the run that needed it. The client owns a selector thread and an executor, + // and the daemon outlives the build -- so a client left open is a set of threads left + // running, and another set for every later build that traces again. + client.close() + client = null } answered.each { Answer answer -> logger.lifecycle(' {}', answer.line) } @@ -438,12 +447,13 @@ abstract class TraceNativeMetadataTask extends DefaultTask { private void awaitStarted(Process process, File output) { long deadline = System.currentTimeMillis() + Duration.ofSeconds(startTimeoutSeconds.get()).toMillis() + StartupLog log = new StartupLog(output) while (System.currentTimeMillis() < deadline) { if (!process.isAlive()) { throw new GradleException('The application ended before it started serving. ' + "What it printed is in ${output}") } - if (output.isFile() && output.text.contains('Started ')) { + if (log.saysItStarted()) { return } if (serving()) { From 709989ae3719594a2d38d1c0f9cbaa23a7d61d48 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:49:33 -0700 Subject: [PATCH 104/115] Record the pages after they are compiled, not before generateNativeMetadata reads build/gsp-classes/main, which compileGroovyPages writes. It reached the build through processResources -- and compileGroovyPages depends on classes, which runs processResources, so consuming the task there put it ahead of all three: generateNativeMetadata -> processResources -> classes -> compileGroovyPages The directory it read was therefore empty on a clean build and stale on any other. Recording the pages is half of what the task exists for, and it recorded none of them; an image built from that metadata is missing every page, which shows up as a page not found at runtime rather than as anything at build time. It was also an undeclared dependency on another task's output, declared @InputFiles on a @CacheableTask. No ordering satisfies both directions, so the output now goes to what runs after the pages are compiled: bootJar, under BOOT-INF/classes as the pages themselves are, and the classpath the image is built from. Putting it in the source set output instead would restore the cycle, because the classes task builds those. Nothing executed this task in a test, which is why it was green. Two now do: one asserts compileGroovyPages runs before generateNativeMetadata, the other that processResources no longer consumes it and bootJar does. Both fail against the previous wiring. --- .../plugin/core/GrailsGradlePlugin.groovy | 52 +++++++++++++++++-- .../core/GrailsNativeImageDefaultsSpec.groovy | 29 +++++++++++ .../native-metadata-ordering/build.gradle | 24 +++++++++ .../gradle.properties | 1 + .../grails-app/conf/application.yml | 0 .../grails-app/views/index.gsp | 3 ++ .../native-metadata-ordering/settings.gradle | 1 + 7 files changed, 106 insertions(+), 4 deletions(-) create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/build.gradle create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/gradle.properties create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/conf/application.yml create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/views/index.gsp create mode 100644 grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/settings.gradle diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 5f9f55c2f18..4ca3a071da2 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -55,6 +55,7 @@ import org.gradle.api.provider.Provider import org.gradle.api.tasks.AbstractCopyTask import org.gradle.api.tasks.JavaExec import org.gradle.api.tasks.SourceSet +import org.gradle.api.tasks.bundling.Jar import org.gradle.api.tasks.TaskContainer import org.gradle.api.tasks.TaskProvider import org.gradle.api.tasks.compile.GroovyCompile @@ -95,6 +96,9 @@ class GrailsGradlePlugin implements Plugin { private static final String NATIVE_IMAGE_PLUGIN = 'org.graalvm.buildtools.native' + /** The plugin that compiles the pages, which are half of what a native image has to be told about. */ + private static final String GSP_PLUGIN = 'org.apache.grails.gradle.grails-gsp' + private static final String SPRING_BOOT_PLUGIN = 'org.springframework.boot' private static final String ASSET_COMPILE_TASK = 'assetCompile' @@ -1385,8 +1389,9 @@ ${importStatements} task.group = BasePlugin.BUILD_GROUP task.description = 'Records the application classes and pages a native image must keep' // The classes directory is written by more than one task, so the dependency has to be - // stated. It is stated against the compilation rather than the classes task, because - // the classes task also runs processResources, which consumes this task's output. + // stated. Against the compilations rather than the classes task, because what reads + // this task's output has to run after the pages are compiled, and compiling the pages + // runs the classes task -- see where the output is consumed, below. task.dependsOn(project.tasks.named(sourceSet.compileJavaTaskName)) // Asked of the names rather than of the tasks: findByName creates the task in order to // answer whether it exists, so a build pays for one it may not have depended on. @@ -1407,8 +1412,47 @@ ${importStatements} task.outputDirectory.set(project.layout.buildDirectory.dir('generated-resources/grails-native')) } - project.tasks.named(sourceSet.processResourcesTaskName, ProcessResources).configure { ProcessResources task -> - task.from(metadataTask) + // The pages are half of what this records, and they are compiled by compileGroovyPages. + project.pluginManager.withPlugin(GSP_PLUGIN) { + metadataTask.configure { GenerateNativeMetadataTask task -> + task.dependsOn(project.tasks.named('compileGroovyPages')) + } + } + + // Consumed after the classes exist rather than through processResources. + // + // processResources looks like the natural home for a generated resource, and it was the + // home until it turned out to invert the order this task needs: compileGroovyPages depends + // on classes, classes runs processResources, and processResources consuming this task put + // it ahead of all three. The pages were therefore compiled after the task that reads them + // had already run -- so the page half of the metadata was empty on a clean build and stale + // on any other, and an image built from it was missing every page. Nothing failed; the + // pages were simply not found at runtime. + // + // No ordering satisfies both directions, so the output goes to what runs after the pages + // are compiled: the archive, and the image being built from it. Adding it to the source + // set output instead would put the cycle back, because the classes task builds those. + project.tasks.withType(Jar).configureEach { Jar jar -> + if (jar.name == 'bootJar') { + jar.from(metadataTask) { CopySpec spec -> spec.into('BOOT-INF/classes') } + } + } + addToNativeImageClasspath(project, metadataTask) + } + + /** + * Puts the recorded metadata on the classpath the image is built from. + * + *

    Dynamically, because the plugin that defines the extension is not on this plugin's compile + * classpath -- and it is only asked for inside {@code withPlugin}, so an application that never + * builds an image never reaches it.

    + */ + @CompileDynamic + private static void addToNativeImageClasspath(Project project, + TaskProvider metadataTask) { + def graalvm = project.extensions.findByName('graalvmNative') + graalvm?.binaries?.configureEach { binary -> + binary.classpath(metadataTask) } } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy index e95110ef648..3c54876b96b 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/core/GrailsNativeImageDefaultsSpec.groovy @@ -69,4 +69,33 @@ class GrailsNativeImageDefaultsSpec extends GradleSpecification { then: 'a classic call site defines a class as it runs, which an image has no way to do' result.output.contains('INDY=true') } + + void 'the pages are recorded after they are compiled, not before'() { + given: 'an application with pages, which are half of what an image has to be told about' + setupTestResourceProject('native-metadata-ordering') + + when: 'the archive is built' + BuildResult result = executeTask('bootJar', ['--dry-run']) + + then: 'the task that reads the compiled pages runs after the task that compiles them' + int compiled = result.output.indexOf(':compileGroovyPages') + int recorded = result.output.indexOf(':generateNativeMetadata') + compiled >= 0 + recorded >= 0 + compiled < recorded + } + + void 'the recorded metadata is not reached through processResources'() { + given: 'which would put it ahead of the pages, since compiling those runs the classes task' + setupTestResourceProject('native-metadata-ordering') + + when: + BuildResult result = executeTask('inspectMetadataWiring') + + then: 'so the resource task no longer consumes it' + result.output.contains('PROCESS_RESOURCES_DEPENDS_ON_METADATA=false') + + and: 'and the archive does, which is built once the pages exist' + result.output.contains('BOOTJAR_DEPENDS_ON_METADATA=true') + } } diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/build.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/build.gradle new file mode 100644 index 00000000000..fe48e421d2e --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/build.gradle @@ -0,0 +1,24 @@ +// The order generateNativeMetadata runs in relative to the task that compiles the pages it reads. +// +// It reads build/gsp-classes/main, which compileGroovyPages writes. compileGroovyPages depends on +// classes, and classes runs processResources -- so anything that reaches this task through +// processResources puts it ahead of the pages it is supposed to record, and it records none. +plugins { + id 'org.apache.grails.gradle.grails-app' + id 'org.apache.grails.gradle.grails-gsp' + id 'org.graalvm.buildtools.native' version '1.1.7' +} + +tasks.register('inspectMetadataWiring') { + def resourceTask = tasks.named('processResources') + def bootJarTask = tasks.named('bootJar') + doLast { + // What processResources takes its input from, which must no longer include the metadata. + println "PROCESS_RESOURCES_DEPENDS_ON_METADATA=" + + resourceTask.get().taskDependencies.getDependencies(resourceTask.get()) + .any { it.name == 'generateNativeMetadata' } + println "BOOTJAR_DEPENDS_ON_METADATA=" + + bootJarTask.get().taskDependencies.getDependencies(bootJarTask.get()) + .any { it.name == 'generateNativeMetadata' } + } +} diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/gradle.properties b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/gradle.properties new file mode 100644 index 00000000000..35c332fb874 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/gradle.properties @@ -0,0 +1 @@ +grailsVersion=__PROJECT_VERSION__ diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/conf/application.yml b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/conf/application.yml new file mode 100644 index 00000000000..e69de29bb2d diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/views/index.gsp b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/views/index.gsp new file mode 100644 index 00000000000..5937b3439fa --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/grails-app/views/index.gsp @@ -0,0 +1,3 @@ + +A page, so there is something for the metadata task to record. + diff --git a/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/settings.gradle b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/settings.gradle new file mode 100644 index 00000000000..eeb96ea7904 --- /dev/null +++ b/grails-gradle/plugins/src/test/resources/test-projects/native-metadata-ordering/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'native-metadata-ordering' From e68da7d3db25e5c9752e3998131e2818a4e69d9c Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:53:56 -0700 Subject: [PATCH 105/115] Ask for the asset task by name instead of holding the container project.files(tasks.matching { }) keeps a live TaskCollection, and handing it to bootJar made the task container -- and the project behind it -- reachable from the archive's input files. Resolving those inputs also ran the predicate against every task registered, realizing all of them to find one. Asking the names costs nothing and realizes nothing; only the task that is actually there is then looked up, and the file collection it returns carries the dependency on it. Still by name rather than by the plugin that registers it: the pipeline's plugin id has changed once already, the task name has not, and an application is free to register the task itself -- which is what the spec for this does. --- .../plugin/core/GrailsGradlePlugin.groovy | 24 ++++++++++++++----- 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 4ca3a071da2..af7d0168b8f 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -891,12 +891,24 @@ ${importStatements} */ private void configureAssetsOnTheClasspath(Project project) { project.pluginManager.withPlugin(SPRING_BOOT_PLUGIN) { - // Matched by the task the pipeline registers rather than by the plugin that registers - // it: the asset pipeline's plugin id has changed once already, and the task name has - // not. Matched rather than looked up, so nothing depends on which plugin was applied - // first and no task is resolved to find out. - FileCollection compiledAssets = project.files( - project.tasks.matching { Task task -> task.name == ASSET_COMPILE_TASK }) + // Asked for by name when the archive needs it, rather than matched out of the task + // container in advance. + // + // A matching {} collection is live. Handed to project.files() it became part of + // bootJar's input files, so the container was reachable from the archive's state -- and + // resolving those inputs ran the predicate against every task registered, realizing all + // of them to find the one. Asking the names costs nothing and realizes nothing; only + // the task that is actually there is then looked up, and the file collection it returns + // carries the dependency on it. + // + // Still by name rather than by the plugin that registers it: the pipeline's plugin id + // has changed once already and the task name has not, and an application is free to + // register the task itself. + FileCollection compiledAssets = project.files(project.provider { + project.tasks.names.contains(ASSET_COMPILE_TASK) + ? project.tasks.named(ASSET_COMPILE_TASK).get().outputs.files + : project.files() + }) project.tasks.named('bootJar', AbstractCopyTask).configure { AbstractCopyTask task -> task.from(compiledAssets) { CopySpec spec -> spec.into(CLASSPATH_ASSETS_PATH) From 3890b3466e4eb0a3e5ad9555eeeeabfcb700ad0f Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:53:56 -0700 Subject: [PATCH 106/115] Refuse a port something else is already answering on Whether the application has started is answered in part by connecting to its port, and a connection cannot tell one application from another. So anything already listening on 18080 or 18081 -- a second build on the same CI agent, a developer's own server, a run left behind by a cancelled build -- answered on the application's behalf: the wait ended at once and what was trained or traced was a recording of somebody else's application, reported as a success. The port is now bound before the run is started, and a port that is busy fails the task with the port and the setting that names it. It is not proof against a race, but the case worth catching is a port that is already busy. --- .../grails/gradle/plugin/aot/RunPort.groovy | 64 ++++++++++++++++ .../plugin/aot/TraceNativeMetadataTask.groovy | 1 + .../plugin/aot/TrainAotCacheTask.groovy | 1 + .../gradle/plugin/aot/RunPortSpec.groovy | 74 +++++++++++++++++++ 4 files changed, 140 insertions(+) create mode 100644 grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy new file mode 100644 index 00000000000..c411e02a130 --- /dev/null +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy @@ -0,0 +1,64 @@ +/* + * 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.grails.gradle.plugin.aot + +import groovy.transform.CompileStatic +import org.gradle.api.GradleException + +/** + * The port a run is going to be reached on, checked before the run is started. + * + *

    Whether the application has started is answered in part by connecting to its port, and a + * connection cannot tell one application from another. So anything already listening on the port -- + * a second build on the same CI agent, a developer's own server, a run left behind by a build that + * was cancelled -- answers on the application's behalf: the wait ends immediately, and what is then + * trained or traced is a recording of somebody else's application. It is reported as a success, + * because from the task's point of view nothing went wrong.

    + * + *

    Binding the port first turns that into a failure that names the port, before anything is run. + * It is not proof against a race -- something can take the port between the check and the run -- + * but the case worth catching is a port that is already busy, which this catches every time.

    + */ +@CompileStatic +final class RunPort { + + private RunPort() { + } + + /** + * Refuses where something is already listening on the port. + * + * @param port the port the run will be reached on + * @param what what is being attempted, to open the message with + * @param setting the build setting that names the port, so the message says what to change + */ + static void refuseWhereTaken(int port, String what, String setting) { + try { + new ServerSocket().withCloseable { ServerSocket socket -> + socket.bind(new InetSocketAddress(InetAddress.getByName('localhost'), port), 1) + } + } + catch (IOException ignored) { + throw new GradleException("${what} needs port ${port}, and something is already " + + "listening on it. Whatever answers there would be taken for the application " + + "and recorded in its place. Stop what is using the port, or set ${setting} to " + + 'one that is free.') + } + } +} diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index 8f6c58e1ca7..b0426960357 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -166,6 +166,7 @@ abstract class TraceNativeMetadataTask extends DefaultTask { File metadata = outputDirectory.get().asFile metadata.mkdirs() refuseWithoutAgent(java) + RunPort.refuseWhereTaken(port.get(), 'Tracing what an image needs', 'grails.nativeMetadata.port') List command = [] command << java.absolutePath diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index 1302bc1bc68..937781f5e90 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -108,6 +108,7 @@ abstract class TrainAotCacheTask extends DefaultTask { void train() { refuseWhereTheRunCannotBeAskedToStop() refuseWhereTheJdkCannotWriteACache() + RunPort.refuseWhereTaken(port.get(), 'Training an AOT cache', 'grails.aotCache.port') File directory = applicationDirectory.get().asFile File cache = cacheFile.get().asFile cache.delete() diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.groovy new file mode 100644 index 00000000000..78518acdff3 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.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.grails.gradle.plugin.aot + +import org.gradle.api.GradleException +import spock.lang.Specification + +/** + * Covers refusing a port something else is already answering on. + */ +class RunPortSpec extends Specification { + + void 'a free port is not refused'() { + given: 'a port nothing is listening on, found by letting the system choose one and closing it' + int free = new ServerSocket(0).withCloseable { ServerSocket socket -> socket.localPort } + + when: + RunPort.refuseWhereTaken(free, 'Training an AOT cache', 'grails.aotCache.port') + + then: + noExceptionThrown() + } + + void 'a port something is listening on is refused before anything is run'() { + given: 'something already answering, as a second build on the same agent would be' + ServerSocket taken = new ServerSocket(0, 1, InetAddress.getByName('localhost')) + + when: + RunPort.refuseWhereTaken(taken.localPort, 'Training an AOT cache', 'grails.aotCache.port') + + then: 'rather than the run being started and whatever answers being recorded in its place' + GradleException e = thrown() + e.message.contains(taken.localPort as String) + + and: 'and the message says what to change' + e.message.contains('grails.aotCache.port') + + cleanup: + taken?.close() + } + + void 'the message names whatever was being attempted'() { + given: + ServerSocket taken = new ServerSocket(0, 1, InetAddress.getByName('localhost')) + + when: + RunPort.refuseWhereTaken(taken.localPort, 'Tracing what an image needs', + 'grails.nativeMetadata.port') + + then: + GradleException e = thrown() + e.message.startsWith('Tracing what an image needs') + e.message.contains('grails.nativeMetadata.port') + + cleanup: + taken?.close() + } +} From a3d5a48b3948155195b8d843b1f1d7e26e36e6a9 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 09:55:48 -0700 Subject: [PATCH 107/115] Fingerprint the extraction by the JDK, not by where it lives An absolute JDK path declared as an @Input on a @CacheableTask puts the machine that ran the build into the cache key, so the task could never be hit on CI or on another developer's machine -- which is most of what the annotation is for. The launcher is nested instead, as GroovyPageForkCompileTask already does, so what is fingerprinted is what the launcher says about itself. It is still set as the provider it is, so reading the project does not provision a JDK. --- .../plugin/aot/ExtractApplicationTask.groovy | 18 +++++-- .../plugin/core/GrailsGradlePlugin.groovy | 8 +-- .../aot/ExtractApplicationTaskSpec.groovy | 54 +++++++++++++++++++ 3 files changed, 72 insertions(+), 8 deletions(-) create mode 100644 grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy index f10c4fe0d0d..c294d3428a4 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy @@ -27,12 +27,13 @@ import org.gradle.api.file.FileSystemOperations import org.gradle.api.file.RegularFileProperty import org.gradle.api.provider.Property import org.gradle.api.tasks.CacheableTask -import org.gradle.api.tasks.Input import org.gradle.api.tasks.InputFile +import org.gradle.api.tasks.Nested import org.gradle.api.tasks.OutputDirectory import org.gradle.api.tasks.PathSensitive import org.gradle.api.tasks.PathSensitivity import org.gradle.api.tasks.TaskAction +import org.gradle.jvm.toolchain.JavaLauncher import org.gradle.process.ExecOperations /** @@ -57,11 +58,17 @@ abstract class ExtractApplicationTask extends DefaultTask { abstract RegularFileProperty getArchiveFile() /** - * The java to unpack with. Its {@code jarmode} does the extracting, so it is the JDK the + * The Java runtime to unpack with. Its {@code jarmode} does the extracting, so it is the JDK the * application was built for rather than whichever one is running Gradle. + * + *

    Nested rather than the path as an input. A path is where a JDK happens to live on the + * machine that ran the build, so declaring it as an input puts that machine into this task's + * cache key -- and a cacheable task that can only ever be hit on the machine that filled it is + * not one. Nested fingerprints what the launcher says about itself, which is the part that + * changes the result.

    */ - @Input - abstract Property getJavaExecutable() + @Nested + abstract Property getJavaLauncher() @OutputDirectory abstract DirectoryProperty getDestination() @@ -80,7 +87,8 @@ abstract class ExtractApplicationTask extends DefaultTask { fileSystemOperations.delete { spec -> spec.delete(target) } target.mkdirs() execOperations.exec { spec -> - spec.commandLine(javaExecutable.get(), '-Djarmode=tools', '-jar', + spec.commandLine(javaLauncher.get().executablePath.asFile.absolutePath, + '-Djarmode=tools', '-jar', archiveFile.get().asFile.absolutePath, 'extract', '--destination', target.absolutePath) } diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index af7d0168b8f..38d0ff8c3ba 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -1310,9 +1310,11 @@ ${importStatements} task.description = 'Extracts the application, which is the form the cache is read against' task.onlyIf { extension.enabled.get() } task.archiveFile.set(archiveFileOf(bootJar)) - // Mapped rather than read, so the JDK the toolchain resolves to is not provisioned - // by every build that merely reads this project. - task.javaExecutable.set(launcher.map { JavaLauncher java -> java.executablePath.asFile.absolutePath }) + // The launcher rather than its path: this task is cacheable, and a path is where a + // JDK happens to live on the machine that ran the build. Set as the provider it is, + // so the toolchain is not resolved -- and a JDK not provisioned -- by every build + // that merely reads this project. + task.javaLauncher.set(launcher) task.destination.set(application) } diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy new file mode 100644 index 00000000000..2d5a464a840 --- /dev/null +++ b/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy @@ -0,0 +1,54 @@ +/* + * 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.grails.gradle.plugin.aot + +import org.gradle.api.tasks.CacheableTask +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.Nested +import spock.lang.Specification + +import java.lang.reflect.Method + +/** + * Covers what the extraction is fingerprinted by, which decides whether it can ever be cached. + */ +class ExtractApplicationTaskSpec extends Specification { + + void 'the extraction is cacheable'() { + expect: + ExtractApplicationTask.isAnnotationPresent(CacheableTask) + } + + void 'the JDK is fingerprinted by what it is rather than by where it lives'() { + expect: 'the launcher, whose metadata is the part that changes the result' + ExtractApplicationTask.getMethod('getJavaLauncher').isAnnotationPresent(Nested) + } + + void 'nothing declares a plain value as an input'() { + given: 'a path is where a JDK happens to live on the machine that ran the build, so an ' + + 'input carrying one puts that machine in the cache key -- and a cacheable task ' + + 'that can only be hit on the machine that filled it is not one' + List declared = ExtractApplicationTask.declaredMethods + .findAll { Method method -> method.isAnnotationPresent(Input) } + .collect { Method method -> method.name } + + expect: + declared.isEmpty() + } +} From 416096af49b5c53ecc4977429cb38be76b44811f Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 10:04:00 -0700 Subject: [PATCH 108/115] Say what is wrong instead of publishing through a null Three things, now that this publisher is built by the container rather than handed a context. The cast in setApplicationContext was unchecked, so a context that is not configurable threw a ClassCastException out of a container callback -- out of the container's own setup rather than out of anything this was asked to do. It is narrowed instead, and left unset. Nothing guarded against the field staying null. findEventPublisherClass picks this class when either the registry or resourcePatternResolver.resourceLoader is a ConfigurableApplicationContext, but the bean is built by whoever owns the registry -- so where the registry is a plain DefaultListableBeanFactory and only the resource loader is a context, ApplicationContextAware is never applied and the first publishEvent was a NullPointerException from inside GORM. It now says which situation it is in. And the field is volatile: it stopped being final when the no-argument constructor arrived, and it is written by whichever thread refreshes the container and read by whichever one publishes. --- ...bleApplicationContextEventPublisher.groovy | 44 ++++++++++++++++--- ...pplicationContextEventPublisherSpec.groovy | 35 +++++++++++++++ 2 files changed, 74 insertions(+), 5 deletions(-) diff --git a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy index bdfbfab1f98..8ab422c0fc9 100644 --- a/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy +++ b/grails-datamapping-core/src/main/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisher.groovy @@ -36,7 +36,12 @@ import org.springframework.context.ConfigurableApplicationContext @CompileStatic class ConfigurableApplicationContextEventPublisher implements ConfigurableApplicationEventPublisher, ApplicationContextAware { - ConfigurableApplicationContext applicationContext + /** + * Volatile because it is no longer final. A publisher built without a context is completed by a + * container callback, on whichever thread the container refreshes on, and read later on + * whichever thread publishes an event -- so what one wrote has to be what the other sees. + */ + volatile ConfigurableApplicationContext applicationContext /** * Takes the context from the container. A bean definition built this way holds no @@ -49,23 +54,52 @@ class ConfigurableApplicationContextEventPublisher implements ConfigurableApplic this.applicationContext = applicationContext } + /** + * Narrowed rather than cast. This is a container callback, so a context that is not + * configurable would throw a {@link ClassCastException} out of the container's own setup rather + * than out of anything this was asked to do. Left unset instead, which {@link #context()} + * reports if it is ever used. + */ @Override void setApplicationContext(ApplicationContext applicationContext) { - this.applicationContext = (ConfigurableApplicationContext) applicationContext + if (applicationContext instanceof ConfigurableApplicationContext) { + this.applicationContext = applicationContext + } } @Override void addApplicationListener(ApplicationListener listener) { - this.applicationContext.addApplicationListener(listener) + context().addApplicationListener(listener) } @Override void publishEvent(ApplicationEvent event) { - this.applicationContext.publishEvent(event) + context().publishEvent(event) } @Override void publishEvent(Object event) { - this.applicationContext.publishEvent(event) + context().publishEvent(event) + } + + /** + * The context, or what is wrong if there is not one. + * + *

    A publisher built without a context is completed by {@code ApplicationContextAware}, and + * that callback is applied by the context -- so it never happens where the bean was registered + * in a plain bean factory. Without this, the first event published is a + * {@link NullPointerException} from inside GORM, which says nothing about the bean factory the + * publisher was registered in.

    + */ + private ConfigurableApplicationContext context() { + ConfigurableApplicationContext current = this.applicationContext + if (current == null) { + throw new IllegalStateException('This event publisher has no application context. It is ' + + 'given one by the container, which only happens where it was registered in a ' + + 'ConfigurableApplicationContext -- registered in a plain bean factory, nothing ' + + 'applies ApplicationContextAware to it. Register it in a context, or construct ' + + 'it with the context to publish through.') + } + current } } diff --git a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy index 592f3fbe713..0d0dd4225e1 100644 --- a/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy +++ b/grails-datamapping-core/src/test/groovy/org/grails/datastore/gorm/events/ConfigurableApplicationContextEventPublisherSpec.groovy @@ -18,6 +18,7 @@ */ package org.grails.datastore.gorm.events +import org.springframework.context.ApplicationContext import org.springframework.context.ApplicationListener import org.springframework.context.event.ContextRefreshedEvent import org.springframework.context.support.GenericApplicationContext @@ -77,4 +78,38 @@ class ConfigurableApplicationContextEventPublisherSpec extends Specification { then: publisher.applicationContext.is(context) } + + void 'a context that cannot be configured is declined rather than thrown out of the callback'() { + given: 'setApplicationContext is the container calling in, so what it throws comes out of ' + + 'the container rather than out of anything this was asked to do' + def publisher = new ConfigurableApplicationContextEventPublisher() + + when: + publisher.setApplicationContext(Mock(ApplicationContext)) + + then: + noExceptionThrown() + + and: 'and nothing was taken from it' + publisher.applicationContext == null + } + + void 'a publisher that was never given a context says so rather than failing as a null'() { + given: 'which is what happens where the bean was registered in a plain bean factory: the ' + + 'callback that completes it is applied by a context, so it never runs' + def publisher = new ConfigurableApplicationContextEventPublisher() + + when: + publisher.publishEvent(new ContextRefreshedEvent(context)) + + then: 'rather than a NullPointerException from inside GORM saying nothing about why' + IllegalStateException e = thrown() + e.message.contains('ConfigurableApplicationContext') + + when: + publisher.addApplicationListener({ event -> } as ApplicationListener) + + then: + thrown(IllegalStateException) + } } From 1ece28fbbbef7637d3df178b6be307e98a3333e2 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 10:04:00 -0700 Subject: [PATCH 109/115] Refuse to generate Neo4j definitions that carry the machine's configuration The datastore is given the resolved configuration rather than a reference to the environment, because the method that names the environment was added to AbstractDatastoreInitializer and this build resolves that class from a released artifact. Generating code for that definition writes out what it holds -- the build machine's PropertyResolver, its environment variables among them -- into the application's generated source, and ships it. Nothing said it had happened. Refusing is the lesser outcome: an unsupported combination that says so can be worked around, one that quietly ships the builder's environment cannot be noticed. Also both halves of the event publisher condition. Four initializers register grailsDatastoreEventPublisher under one name and whichever drains last defines it for all of them; the other three accept a resource loader that is a context, so testing only the registry here could leave a Hibernate-and-Neo4j application publishing Hibernate's events through a no-op -- GORM events stopping and auto-timestamping stopping, with nothing logged. --- .../Neo4jDataStoreSpringInitializer.groovy | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy index 19a7df1e52d..b8e43bdef0a 100644 --- a/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy +++ b/grails-data-neo4j/grails-plugin/src/main/groovy/grails/neo4j/bootstrap/Neo4jDataStoreSpringInitializer.groovy @@ -22,6 +22,7 @@ package grails.neo4j.bootstrap import grails.neo4j.Neo4jEntity import grails.spring.BeanBuilder import groovy.transform.InheritConstructors +import org.apache.grails.common.aot.AheadOfTimeProcessing import org.grails.datastore.gorm.bootstrap.AbstractDatastoreInitializer import org.grails.datastore.gorm.events.ConfigurableApplicationContextEventPublisher import org.grails.datastore.gorm.events.DefaultApplicationEventPublisher @@ -67,8 +68,33 @@ class Neo4jDataStoreSpringInitializer extends AbstractDatastoreInitializer { return Neo4jEntity.isAssignableFrom(cls) || super.isMappedClass(datastoreType, cls) } + /** + * Refuses to generate code for a definition that would carry the build machine's settings. + * + *

    The datastore below is given the resolved configuration rather than a reference to the + * environment, because the method that names the environment instead was added to + * {@code AbstractDatastoreInitializer} and this build resolves that class from a released + * artifact rather than from the source beside it -- so the call compiles here and goes missing + * at run time.

    + * + *

    Generating code for a definition means writing out what it holds, and what this one holds + * is a {@code PropertyResolver}: the build machine's environment, its environment variables + * among them, written into the application's generated source and shipped in it. Refusing is + * the lesser outcome. An unsupported combination that says so can be worked around; one that + * quietly ships whatever the machine that built it had cannot be noticed.

    + */ + private static void refuseWhereTheConfigurationWouldBeWrittenOut() { + if (AheadOfTimeProcessing.generatingCode) { + throw new IllegalStateException('Neo4j cannot yet be processed ahead of time. Its bean ' + + 'definitions hold the resolved configuration, and generating code for them ' + + "would write this machine's environment into the application. Remove Spring " + + "Boot's AOT plugin, or the Neo4j datastore, until this is supported.") + } + } + @Override Closure getBeanDefinitions(BeanDefinitionRegistry beanDefinitionRegistry) { + refuseWhereTheConfigurationWouldBeWrittenOut() { -> def callable = getCommonConfiguration(beanDefinitionRegistry, DATASTORE_TYPE) callable.delegate = delegate @@ -82,7 +108,15 @@ class Neo4jDataStoreSpringInitializer extends AbstractDatastoreInitializer { // The choice is made here rather than through AbstractDatastoreInitializer, because this // build resolves that class from a released grails-datamapping-core rather than from // the source beside it, and a method added there is not one this can call. + // Both halves of the condition, because this bean is registered under one name by four + // initializers and whichever drains last defines it for all of them. The other three + // resolve the class through AbstractDatastoreInitializer.findEventPublisherClass, which + // also accepts a resource loader that is a context -- so testing only the registry here + // let a Hibernate-and-Neo4j application end up publishing Hibernate's events through + // DefaultApplicationEventPublisher, which does nothing with them: GORM events stop + // firing and auto-timestamping stops working, with nothing logged. grailsDatastoreEventPublisher(beanDefinitionRegistry instanceof ConfigurableApplicationContext + || resourcePatternResolver.resourceLoader instanceof ConfigurableApplicationContext ? ConfigurableApplicationContextEventPublisher : DefaultApplicationEventPublisher) final boolean isRecentGrailsVersion = GrailsVersion.isAtLeastMajorMinor(3, 3) From db49c9488f61b269822d4afb03e5cf156d07d939 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 10:10:31 -0700 Subject: [PATCH 110/115] Quote the port message the way CodeNarc asks --- .../src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy index c411e02a130..09bf5afc79f 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy @@ -56,7 +56,7 @@ final class RunPort { } catch (IOException ignored) { throw new GradleException("${what} needs port ${port}, and something is already " + - "listening on it. Whatever answers there would be taken for the application " + + 'listening on it. Whatever answers there would be taken for the application ' + "and recorded in its place. Stop what is using the port, or set ${setting} to " + 'one that is free.') } From e28672d89e82802f0ec8c7fb53ee66143f0872dc Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 11:39:56 -0700 Subject: [PATCH 111/115] Move the Gradle plugin's AOT classes to org.apache.grails org.grails.gradle.plugin.aot -> org.apache.grails.gradle.plugin.aot, for the eight classes this PR adds and their specs. They stay together in an .aot package beside the plugin they belong to; only the root changes. grails-gradle/common already publishes org.apache.grails.gradle.common, so this is the direction that module was already going. --- .../gradle/plugin/aot/AotCacheExtension.groovy | 2 +- .../gradle/plugin/aot/ExtractApplicationTask.groovy | 2 +- .../plugin/aot/GenerateNativeMetadataTask.groovy | 2 +- .../gradle/plugin/aot/NativeMetadataExtension.groovy | 2 +- .../grails/gradle/plugin/aot/RunPort.groovy | 2 +- .../grails/gradle/plugin/aot/StartupLog.groovy | 2 +- .../gradle/plugin/aot/TraceNativeMetadataTask.groovy | 2 +- .../gradle/plugin/aot/TrainAotCacheTask.groovy | 2 +- .../gradle/plugin/core/GrailsGradlePlugin.groovy | 12 ++++++------ .../plugin/aot/ExtractApplicationTaskSpec.groovy | 2 +- .../plugin/aot/GenerateNativeMetadataTaskSpec.groovy | 2 +- .../grails/gradle/plugin/aot/RunPortSpec.groovy | 2 +- .../grails/gradle/plugin/aot/StartupLogSpec.groovy | 2 +- .../plugin/aot/TraceNativeMetadataTaskSpec.groovy | 2 +- .../grails/gradle/plugin/aot/TracedRunFixture.groovy | 2 +- .../gradle/plugin/aot/TrainAotCacheTaskSpec.groovy | 2 +- .../gradle/plugin/aot/TrainingRunFixture.groovy | 2 +- 17 files changed, 22 insertions(+), 22 deletions(-) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/AotCacheExtension.groovy (98%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/ExtractApplicationTask.groovy (98%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy (99%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/NativeMetadataExtension.groovy (98%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/RunPort.groovy (98%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/StartupLog.groovy (98%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy (99%) rename grails-gradle/plugins/src/main/groovy/org/{ => apache}/grails/gradle/plugin/aot/TrainAotCacheTask.groovy (99%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy (98%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy (99%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/RunPortSpec.groovy (98%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/StartupLogSpec.groovy (99%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy (99%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/TracedRunFixture.groovy (99%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy (99%) rename grails-gradle/plugins/src/test/groovy/org/{ => apache}/grails/gradle/plugin/aot/TrainingRunFixture.groovy (98%) diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/AotCacheExtension.groovy similarity index 98% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/AotCacheExtension.groovy index c35a271a99e..10968b48f52 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/AotCacheExtension.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/AotCacheExtension.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import groovy.transform.CompileStatic import org.gradle.api.provider.ListProperty diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/ExtractApplicationTask.groovy similarity index 98% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/ExtractApplicationTask.groovy index c294d3428a4..467793ce12f 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/ExtractApplicationTask.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import javax.inject.Inject diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy similarity index 99% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy index c7bb024106b..c1c19950f27 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/GenerateNativeMetadataTask.groovy @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import groovy.json.JsonOutput import groovy.transform.CompileStatic diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/NativeMetadataExtension.groovy similarity index 98% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/NativeMetadataExtension.groovy index 9984411e12f..f92f355494d 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/NativeMetadataExtension.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/NativeMetadataExtension.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import groovy.transform.CompileStatic import org.gradle.api.file.DirectoryProperty diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/RunPort.groovy similarity index 98% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/RunPort.groovy index 09bf5afc79f..6d8d015ddc5 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/RunPort.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/RunPort.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import groovy.transform.CompileStatic import org.gradle.api.GradleException diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/StartupLog.groovy similarity index 98% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/StartupLog.groovy index 633a6dbf1b2..e00a2ea990d 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/StartupLog.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/StartupLog.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import groovy.transform.CompileStatic diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy similarity index 99% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy index b0426960357..c9395dd82e5 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/TraceNativeMetadataTask.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import java.net.http.HttpClient import java.net.http.HttpRequest diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/TrainAotCacheTask.groovy similarity index 99% rename from grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy rename to grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/TrainAotCacheTask.groovy index 937781f5e90..b4fff274c88 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTask.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/apache/grails/gradle/plugin/aot/TrainAotCacheTask.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import java.security.MessageDigest import java.time.Duration diff --git a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy index 38d0ff8c3ba..8f0918d7678 100644 --- a/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy +++ b/grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy @@ -70,12 +70,12 @@ import org.grails.gradle.plugin.commands.GrailsCliGradlePlugin import org.grails.gradle.plugin.exploded.ExplodedCompatibilityRule import org.grails.gradle.plugin.exploded.ExplodedDisambiguationRule import org.grails.gradle.plugin.exploded.GrailsExplodedPlugin -import org.grails.gradle.plugin.aot.AotCacheExtension -import org.grails.gradle.plugin.aot.ExtractApplicationTask -import org.grails.gradle.plugin.aot.GenerateNativeMetadataTask -import org.grails.gradle.plugin.aot.NativeMetadataExtension -import org.grails.gradle.plugin.aot.TraceNativeMetadataTask -import org.grails.gradle.plugin.aot.TrainAotCacheTask +import org.apache.grails.gradle.plugin.aot.AotCacheExtension +import org.apache.grails.gradle.plugin.aot.ExtractApplicationTask +import org.apache.grails.gradle.plugin.aot.GenerateNativeMetadataTask +import org.apache.grails.gradle.plugin.aot.NativeMetadataExtension +import org.apache.grails.gradle.plugin.aot.TraceNativeMetadataTask +import org.apache.grails.gradle.plugin.aot.TrainAotCacheTask import org.grails.gradle.plugin.model.GrailsClasspathToolingModelBuilder import org.grails.gradle.plugin.run.FindMainClassTask import org.grails.gradle.plugin.util.SourceSets diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy similarity index 98% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy index 2d5a464a840..4c20f391ea9 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/ExtractApplicationTaskSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import org.gradle.api.tasks.CacheableTask import org.gradle.api.tasks.Input diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy similarity index 99% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy index 6a26597ecd9..31776aafd70 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/GenerateNativeMetadataTaskSpec.groovy @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import java.util.jar.JarEntry import java.util.jar.JarOutputStream diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/RunPortSpec.groovy similarity index 98% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/RunPortSpec.groovy index 78518acdff3..941573d27f3 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/RunPortSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/RunPortSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import org.gradle.api.GradleException import spock.lang.Specification diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/StartupLogSpec.groovy similarity index 99% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/StartupLogSpec.groovy index 0223e45f4f8..2bfb41ab9b9 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/StartupLogSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/StartupLogSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import spock.lang.Specification import spock.lang.TempDir diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy similarity index 99% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy index bcda3058af7..1c27fb1687d 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TraceNativeMetadataTaskSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import java.net.CookieHandler import java.net.CookieManager diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TracedRunFixture.groovy similarity index 99% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TracedRunFixture.groovy index ae9d71e43dc..7785db385bb 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TracedRunFixture.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TracedRunFixture.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import java.util.concurrent.CountDownLatch diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy similarity index 99% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy index 642fd89377c..6e91a595a76 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TrainAotCacheTaskSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import org.gradle.api.GradleException import org.gradle.api.Project diff --git a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TrainingRunFixture.groovy similarity index 98% rename from grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy rename to grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TrainingRunFixture.groovy index 89e7af2a8bb..90559bb3810 100644 --- a/grails-gradle/plugins/src/test/groovy/org/grails/gradle/plugin/aot/TrainingRunFixture.groovy +++ b/grails-gradle/plugins/src/test/groovy/org/apache/grails/gradle/plugin/aot/TrainingRunFixture.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.gradle.plugin.aot +package org.apache.grails.gradle.plugin.aot import java.util.concurrent.CountDownLatch From 63a462a77674cf3b9c93e83fcdbfdfe4dcc3f72d Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Sun, 16 Aug 2026 11:56:54 -0700 Subject: [PATCH 112/115] Move the tag library bean registration to org.apache.grails org.grails.plugins.web.TagLibBeanDefinitionsPostProcessor -> org.apache.grails.gsp.taglib.TagLibBeanDefinitionsPostProcessor, with its spec. Newly added code, so it goes under org.apache.grails like the rest of what this PR adds. Not under an .aot package: the reason it exists is that doWithSpring re-registered over generated definitions, but GroovyPagesGrailsPlugin registers it unconditionally and it runs in every environment. --- .../gsp/taglib}/TagLibBeanDefinitionsPostProcessor.groovy | 2 +- .../org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy | 1 + .../gsp/taglib}/TagLibBeanDefinitionsPostProcessorSpec.groovy | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) rename grails-gsp/plugin/src/main/groovy/org/{grails/plugins/web => apache/grails/gsp/taglib}/TagLibBeanDefinitionsPostProcessor.groovy (99%) rename grails-gsp/plugin/src/test/groovy/org/{grails/plugins/web => apache/grails/gsp/taglib}/TagLibBeanDefinitionsPostProcessorSpec.groovy (99%) diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy b/grails-gsp/plugin/src/main/groovy/org/apache/grails/gsp/taglib/TagLibBeanDefinitionsPostProcessor.groovy similarity index 99% rename from grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy rename to grails-gsp/plugin/src/main/groovy/org/apache/grails/gsp/taglib/TagLibBeanDefinitionsPostProcessor.groovy index 111f436141e..8b181fb0810 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessor.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/apache/grails/gsp/taglib/TagLibBeanDefinitionsPostProcessor.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.plugins.web +package org.apache.grails.gsp.taglib import groovy.transform.CompileStatic import groovy.util.logging.Slf4j diff --git a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy index 6011ac2ae9f..3a274eb2835 100644 --- a/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy +++ b/grails-gsp/plugin/src/main/groovy/org/grails/plugins/web/GroovyPagesGrailsPlugin.groovy @@ -38,6 +38,7 @@ import grails.util.GrailsUtil import grails.util.Metadata import grails.web.pages.GroovyPagesUriService import org.apache.grails.common.aot.AheadOfTimeProcessing +import org.apache.grails.gsp.taglib.TagLibBeanDefinitionsPostProcessor import org.grails.core.artefact.gsp.TagLibArtefactHandler import org.grails.gsp.GroovyPageResourceLoader import org.grails.gsp.GroovyPagesTemplateEngine diff --git a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy b/grails-gsp/plugin/src/test/groovy/org/apache/grails/gsp/taglib/TagLibBeanDefinitionsPostProcessorSpec.groovy similarity index 99% rename from grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy rename to grails-gsp/plugin/src/test/groovy/org/apache/grails/gsp/taglib/TagLibBeanDefinitionsPostProcessorSpec.groovy index 591e36bc703..57791e4a3e3 100644 --- a/grails-gsp/plugin/src/test/groovy/org/grails/plugins/web/TagLibBeanDefinitionsPostProcessorSpec.groovy +++ b/grails-gsp/plugin/src/test/groovy/org/apache/grails/gsp/taglib/TagLibBeanDefinitionsPostProcessorSpec.groovy @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package org.grails.plugins.web +package org.apache.grails.gsp.taglib import grails.core.DefaultGrailsApplication import grails.core.GrailsApplication From 6d468648a8d4ab03082090733c2a750b1b790b89 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Mon, 17 Aug 2026 08:26:16 -0700 Subject: [PATCH 113/115] Take asset pipeline 5.2.0-M3 The release carrying the changes this PR depends on. Both pins move together: asset-pipeline-gradle for the build plugin, asset-pipeline-bom for what the application resolves. --- dependencies.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dependencies.gradle b/dependencies.gradle index ad18672d592..5942876784c 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -26,7 +26,7 @@ ext { 'asciidoctor-gradle-jvm.version': '4.0.5', 'asciidoctorj.version' : '3.0.0', 'asm.version' : '9.10.1', - 'asset-pipeline-gradle.version' : '5.2.0-M1', + 'asset-pipeline-gradle.version' : '5.2.0-M3', 'commons-text.version' : '1.15.0', 'directory-watcher.version' : '0.19.1', 'gradle-groovy.version' : '4.0.33', @@ -80,7 +80,7 @@ ext { ] bomDependencyVersions = [ - 'asset-pipeline-bom.version' : '5.2.0-M1', + 'asset-pipeline-bom.version' : '5.2.0-M3', 'cas-client-core.version' : '4.1.1', 'bootstrap-icons.version' : '1.13.1', 'bootstrap.version' : '5.3.8', From 5c836c436fbaa7ca19453e2d575c7dd9bf0f1fff Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 19 Aug 2026 11:05:13 -0700 Subject: [PATCH 114/115] Name the controller types this module declares as types Six of the seven hinted types are declared by grails-controllers itself or by the JDK, so they are referenced as class literals: a rename is then a compile error here rather than a hint that quietly stops matching, which would surface as a failed dispatch on the first request that took that path. grails.artefact.controller.RestResponder stays a string. It is contributed by grails-rest-transforms, which this module does not depend on, so it cannot be referenced and registerTypeIfPresent is what keeps it correct for an application that does not have it. The spec's absence test asserted only that nothing threw; it now also asserts that the unresolvable type contributes no hint while the module's own types are registered regardless of what the class loader can find. --- .../aot/ControllerRuntimeHints.java | 53 +++++++++++++------ .../aot/ControllerRuntimeHintsSpec.groovy | 17 ++++-- 2 files changed, 52 insertions(+), 18 deletions(-) diff --git a/grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java b/grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java index b18db916b0e..d8aacb80b36 100644 --- a/grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java +++ b/grails-controllers/src/main/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHints.java @@ -18,12 +18,20 @@ */ package org.apache.grails.controllers.aot; +import java.security.Principal; + import org.jspecify.annotations.Nullable; import org.springframework.aot.hint.MemberCategory; import org.springframework.aot.hint.RuntimeHints; import org.springframework.aot.hint.RuntimeHintsRegistrar; +import grails.artefact.Controller; +import grails.artefact.controller.support.AllowedMethodsHelper; +import grails.artefact.controller.support.RequestForwarder; +import grails.artefact.controller.support.ResponseRedirector; +import grails.artefact.controller.support.ResponseRenderer; + /** * Registers the controller API a request is dispatched through. * @@ -41,29 +49,44 @@ */ public class ControllerRuntimeHints implements RuntimeHintsRegistrar { + /** What a hinted type is registered for: the members Groovy reads to choose an overload. */ + private static final MemberCategory[] DISPATCHED_MEMBERS = { + MemberCategory.INVOKE_DECLARED_METHODS, + MemberCategory.INVOKE_PUBLIC_METHODS, + MemberCategory.INVOKE_DECLARED_CONSTRUCTORS + }; + /** - * Types Groovy dispatches on while handling a request. Named as strings, and registered only - * when present, so this stays correct for an application that does not use every plugin. + * Types Groovy dispatches on that this module declares itself, so they are named as types. A + * rename is then a compile error here rather than a hint that quietly stops matching -- which + * would show up as a failed dispatch on the first request that took that path. */ - private static final String[] DISPATCHED_TYPES = { - "grails.artefact.Controller", - "grails.artefact.controller.support.AllowedMethodsHelper", - "grails.artefact.controller.support.RequestForwarder", - "grails.artefact.controller.support.ResponseRedirector", - "grails.artefact.controller.support.ResponseRenderer", - "grails.artefact.controller.RestResponder", + private static final Class[] DISPATCHED_TYPES = { + Controller.class, + AllowedMethodsHelper.class, + RequestForwarder.class, + ResponseRedirector.class, + ResponseRenderer.class, // a view asking who is logged in reaches the request's principal, and Groovy makes that // call on the interface rather than the implementation the container supplies - "java.security.Principal" + Principal.class + }; + + /** + * Types contributed by a module this one does not depend on. Named as strings and registered + * only when present, so this stays correct for an application that does not use every plugin. + */ + private static final String[] OPTIONAL_DISPATCHED_TYPES = { + "grails.artefact.controller.RestResponder" }; @Override public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) { - for (String type : DISPATCHED_TYPES) { - hints.reflection().registerTypeIfPresent(classLoader, type, - MemberCategory.INVOKE_DECLARED_METHODS, - MemberCategory.INVOKE_PUBLIC_METHODS, - MemberCategory.INVOKE_DECLARED_CONSTRUCTORS); + for (Class type : DISPATCHED_TYPES) { + hints.reflection().registerType(type, DISPATCHED_MEMBERS); + } + for (String type : OPTIONAL_DISPATCHED_TYPES) { + hints.reflection().registerTypeIfPresent(classLoader, type, DISPATCHED_MEMBERS); } } } diff --git a/grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy b/grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy index 144e40ff4bf..32bf2ccba48 100644 --- a/grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy +++ b/grails-controllers/src/test/groovy/org/apache/grails/controllers/aot/ControllerRuntimeHintsSpec.groovy @@ -39,7 +39,11 @@ class ControllerRuntimeHintsSpec extends Specification { } private boolean registered(Class type) { - def hint = hints.reflection().getTypeHint(TypeReference.of(type)) + registered(TypeReference.of(type)) + } + + private boolean registered(TypeReference type) { + def hint = hints.reflection().getTypeHint(type) hint != null && hint.memberCategories.contains(MemberCategory.INVOKE_DECLARED_METHODS) } @@ -60,14 +64,21 @@ class ControllerRuntimeHintsSpec extends Specification { registered(grails.artefact.controller.support.RequestForwarder) } - void 'a type absent from the classpath is skipped rather than failing the build'() { + void 'a type from a module that is absent is skipped rather than failing the build'() { given: RuntimeHints empty = new RuntimeHints() - when: 'no class loader can resolve the named types' + when: 'a class loader that resolves nothing, as an application without that plugin has' new ControllerRuntimeHints().registerHints(empty, new URLClassLoader(new URL[0], null)) then: noExceptionThrown() + + and: 'the type it could not resolve contributes no hint' + empty.reflection().getTypeHint( + TypeReference.of('grails.artefact.controller.RestResponder')) == null + + and: 'while the types this module declares are registered whatever a class loader can find' + empty.reflection().getTypeHint(TypeReference.of(AllowedMethodsHelper)) != null } } From ac919290f35570c162d59df54485fb8a6b28f683 Mon Sep 17 00:00:00 2001 From: Scott Murphy Heiberg Date: Wed, 19 Aug 2026 13:41:57 -0700 Subject: [PATCH 115/115] Take SiteMesh 3.3.0-RC1 starter-sitemesh and spring-webmvc-sitemesh move off 3.3.0-SNAPSHOT together; sitemesh itself follows through the starter, so all three resolve at RC1. No -SNAPSHOT version is left in either dependencies.gradle. --- dependencies.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dependencies.gradle b/dependencies.gradle index 5942876784c..4a597099298 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -126,8 +126,8 @@ ext { 'sitemesh.version' : '2.6.0', 'scribejava.version' : '8.3.3', 'spock.version' : '2.4-groovy-5.0', - 'starter-sitemesh.version' : '3.3.0-SNAPSHOT', - 'spring-webmvc-sitemesh.version': '3.3.0-SNAPSHOT', + 'starter-sitemesh.version' : '3.3.0-RC1', + 'spring-webmvc-sitemesh.version': '3.3.0-RC1', // Spring Boot 4 no longer manages spring-retry; pin it here so the // grails-shell-cli SpringRetryCompilerAutoConfiguration's unversioned // reference resolves and consumer apps using @Retryable get a known version.