Merge pull request #31199 from gsmet/2.16.3-backports-1

2.16.3 backports 1

bom/application/pom.xml

@@ -1277,6 +1277,11 @@
                 <artifactId>quarkus-jdbc-derby-deployment</artifactId>
                 <version>${project.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.quarkus</groupId>
+                <artifactId>quarkus-jms-spi-deployment</artifactId>
+                <version>${project.version}</version>
+            </dependency>
             <dependency>
                 <groupId>io.quarkus</groupId>
                 <artifactId>quarkus-kafka-client</artifactId>

core/deployment/src/main/java/io/quarkus/deployment/configuration/RunTimeConfigurationGenerator.java

@@ -398,11 +398,6 @@ public static final class GenerateOperation implements AutoCloseable {
                 clinit.invokeStaticMethod(CU_ADD_SOURCE_FACTORY_PROVIDER, buildTimeBuilder,
                         clinit.newInstance(RCSF_NEW, clinit.load(discoveredConfigSourceFactory)));
             }
-            // add mappings
-            for (ConfigClassWithPrefix configMapping : staticConfigMappings) {
-                clinit.invokeStaticMethod(CU_WITH_MAPPING, buildTimeBuilder,
-                        clinit.load(configMapping.getKlass().getName()), clinit.load(configMapping.getPrefix()));
-            }
 
             // additional config builders
             ResultHandle configBuilders = clinit.newInstance(AL_NEW);
@@ -465,11 +460,12 @@ public void run() {
                     reinit.invokeStaticMethod(CU_ADD_SOURCE_FACTORY_PROVIDER, buildTimeBuilder,
                             reinit.newInstance(RCSF_NEW, reinit.load(discoveredConfigSourceFactory)));
                 }
-                // add mappings
-                for (ConfigClassWithPrefix configMapping : staticConfigMappings) {
-                    reinit.invokeStaticMethod(CU_WITH_MAPPING, buildTimeBuilder,
-                            reinit.load(configMapping.getKlass().getName()), reinit.load(configMapping.getPrefix()));
+                // additional config builders
+                ResultHandle configBuilders = reinit.newInstance(AL_NEW);
+                for (String configBuilder : staticConfigBuilders) {
+                    reinit.invokeVirtualMethod(AL_ADD, configBuilders, reinit.load(configBuilder));
                 }
+                reinit.invokeStaticMethod(CU_CONFIG_BUILDER_LIST, buildTimeBuilder, configBuilders);
 
                 ResultHandle clinitConfig = reinit.checkCast(reinit.invokeVirtualMethod(SRCB_BUILD, buildTimeBuilder),
                         SmallRyeConfig.class);
@@ -552,12 +548,6 @@ public void run() {
                     readBootstrapConfig.invokeStaticMethod(CU_ADD_SOURCE_FACTORY_PROVIDER, bootstrapBuilder,
                             readBootstrapConfig.newInstance(RCSF_NEW, readBootstrapConfig.load(discoveredConfigSourceFactory)));
                 }
-                // add bootstrap mappings
-                for (ConfigClassWithPrefix configMapping : staticConfigMappings) {
-                    readBootstrapConfig.invokeStaticMethod(CU_WITH_MAPPING, bootstrapBuilder,
-                            readBootstrapConfig.load(configMapping.getKlass().getName()),
-                            readBootstrapConfig.load(configMapping.getPrefix()));
-                }
 
                 // add bootstrap config builders
                 ResultHandle bootstrapConfigBuilders = readBootstrapConfig.newInstance(AL_NEW);
@@ -646,12 +636,6 @@ public void run() {
                         readConfig.newInstance(RCSF_NEW, readConfig.load(discoveredConfigSourceFactory)));
             }
 
-            // add mappings
-            for (ConfigClassWithPrefix configMapping : runtimeConfigMappings) {
-                readConfig.invokeStaticMethod(CU_WITH_MAPPING, runTimeBuilder,
-                        readConfig.load(configMapping.getKlass().getName()), readConfig.load(configMapping.getPrefix()));
-            }
-
             // additional config builders
             ResultHandle configBuilders = readConfig.newInstance(AL_NEW);
             for (String configBuilder : runtimeConfigBuilders) {

core/deployment/src/main/java/io/quarkus/deployment/steps/ConfigGenerationBuildStep.java

@@ -88,6 +88,10 @@ public class ConfigGenerationBuildStep {
             SmallRyeConfigBuilder.class, "withSources",
             SmallRyeConfigBuilder.class, ConfigSource[].class);
 
+    private static final MethodDescriptor WITH_MAPPING = MethodDescriptor.ofMethod(
+            SmallRyeConfigBuilder.class, "withMapping",
+            SmallRyeConfigBuilder.class, Class.class, String.class);
+
     @BuildStep
     void staticInitSources(
             BuildProducer<StaticInitConfigSourceProviderBuildItem> staticInitConfigSourceProviderBuildItem,
@@ -217,6 +221,33 @@ void extensionMappings(ConfigurationBuildItem configItem,
         }
     }
 
+    @BuildStep
+    void builderMappings(
+            ConfigurationBuildItem configItem,
+            List<ConfigMappingBuildItem> configMappings,
+            BuildProducer<GeneratedClassBuildItem> generatedClass,
+            BuildProducer<ReflectiveClassBuildItem> reflectiveClass,
+            BuildProducer<StaticInitConfigBuilderBuildItem> staticInitConfigBuilder,
+            BuildProducer<RunTimeConfigBuilderBuildItem> runTimeConfigBuilder) {
+
+        // For Static Init Config
+        Set<ConfigClassWithPrefix> staticMappings = new HashSet<>();
+        staticMappings.addAll(staticSafeConfigMappings(configMappings));
+        staticMappings.addAll(configItem.getReadResult().getBuildTimeRunTimeMappings());
+        String staticInitMappingsConfigBuilder = "io.quarkus.runtime.generated.StaticInitMappingsConfigBuilder";
+        generateMappingsConfigBuilder(generatedClass, reflectiveClass, staticInitMappingsConfigBuilder, staticMappings);
+        staticInitConfigBuilder.produce(new StaticInitConfigBuilderBuildItem(staticInitMappingsConfigBuilder));
+
+        // For RunTime Config
+        Set<ConfigClassWithPrefix> runTimeMappings = new HashSet<>();
+        runTimeMappings.addAll(runtimeConfigMappings(configMappings));
+        runTimeMappings.addAll(configItem.getReadResult().getBuildTimeRunTimeMappings());
+        runTimeMappings.addAll(configItem.getReadResult().getRunTimeMappings());
+        String runTimeMappingsConfigBuilder = "io.quarkus.runtime.generated.RunTimeMappingsConfigBuilder";
+        generateMappingsConfigBuilder(generatedClass, reflectiveClass, runTimeMappingsConfigBuilder, runTimeMappings);
+        runTimeConfigBuilder.produce(new RunTimeConfigBuilderBuildItem(runTimeMappingsConfigBuilder));
+    }
+
     /**
      * Generate the Config class that instantiates MP Config and holds all the config objects
      */
@@ -256,6 +287,7 @@ void generateConfigClass(
         staticConfigSourceFactories.addAll(staticInitConfigSourceFactories.stream()
                 .map(StaticInitConfigSourceFactoryBuildItem::getFactoryClassName).collect(Collectors.toSet()));
 
+        // TODO - duplicated now builderMappings. Still required to filter the unknown properties
         Set<ConfigClassWithPrefix> staticMappings = new HashSet<>();
         staticMappings.addAll(staticSafeConfigMappings(configMappings));
         staticMappings.addAll(configItem.getReadResult().getBuildTimeRunTimeMappings());
@@ -470,6 +502,34 @@ private static void generateDefaultsConfigSource(
         reflectiveClass.produce(new ReflectiveClassBuildItem(true, false, false, className));
     }
 
+    private static void generateMappingsConfigBuilder(
+            BuildProducer<GeneratedClassBuildItem> generatedClass,
+            BuildProducer<ReflectiveClassBuildItem> reflectiveClass,
+            String className,
+            Set<ConfigClassWithPrefix> mappings) {
+
+        try (ClassCreator classCreator = ClassCreator.builder()
+                .classOutput(new GeneratedClassGizmoAdaptor(generatedClass, true))
+                .className(className)
+                .interfaces(ConfigBuilder.class)
+                .setFinal(true)
+                .build()) {
+
+            MethodCreator method = classCreator.getMethodCreator(CONFIG_BUILDER);
+            ResultHandle configBuilder = method.getMethodParam(0);
+
+            for (ConfigClassWithPrefix mapping : mappings) {
+                method.invokeVirtualMethod(WITH_MAPPING, configBuilder,
+                        method.loadClass(mapping.getKlass()),
+                        method.load(mapping.getPrefix()));
+            }
+
+            method.returnValue(configBuilder);
+        }
+
+        reflectiveClass.produce(new ReflectiveClassBuildItem(true, false, false, className));
+    }
+
     private static Set<String> discoverService(
             Class<?> serviceClass,
             BuildProducer<ReflectiveClassBuildItem> reflectiveClass) throws IOException {

devtools/maven/src/main/java/io/quarkus/maven/GoOfflineMojo.java

@@ -5,6 +5,7 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecutionException;
@@ -28,6 +29,7 @@
 import io.quarkus.bootstrap.resolver.maven.workspace.LocalProject;
 import io.quarkus.bootstrap.resolver.maven.workspace.LocalWorkspace;
 import io.quarkus.bootstrap.util.IoUtils;
+import io.quarkus.bootstrap.workspace.ArtifactSources;
 import io.quarkus.maven.dependency.ArtifactCoords;
 import io.quarkus.runtime.LaunchMode;
 
@@ -39,19 +41,27 @@
 public class GoOfflineMojo extends AbstractMojo {
 
     @Parameter(defaultValue = "${project}", readonly = true, required = true)
-    protected MavenProject project;
+    MavenProject project;
 
     @Component
-    private RepositorySystem repoSystem;
+    RepositorySystem repoSystem;
 
     @Component
     RemoteRepositoryManager remoteRepositoryManager;
 
     @Parameter(defaultValue = "${repositorySystemSession}", readonly = true)
-    private RepositorySystemSession repoSession;
+    RepositorySystemSession repoSession;
 
     @Parameter(defaultValue = "${project.remoteProjectRepositories}", readonly = true, required = true)
-    private List<RemoteRepository> repos;
+    List<RemoteRepository> repos;
+
+    /**
+     * Target launch mode corresponding to {@link io.quarkus.runtime.LaunchMode} for which the dependencies should be resolved.
+     * {@code io.quarkus.runtime.LaunchMode.TEST} is the default, since it includes both {@code provided} and {@code test}
+     * dependency scopes.
+     */
+    @Parameter(property = "mode", required = false, defaultValue = "test")
+    String mode;
 
     @Override
     public void execute() throws MojoExecutionException, MojoFailureException {
@@ -62,43 +72,47 @@ public void execute() throws MojoExecutionException, MojoFailureException {
                 project.getVersion());
 
         final MavenArtifactResolver resolver = getResolver();
+        final BootstrapAppModelResolver appModelResolver = new BootstrapAppModelResolver(resolver);
+
+        final Set<String> excludedScopes;
+        if (mode.equalsIgnoreCase("test")) {
+            appModelResolver.setTest(true);
+            excludedScopes = Set.of();
+        } else if (mode.equalsIgnoreCase("dev") || mode.equalsIgnoreCase("development")) {
+            appModelResolver.setDevMode(true);
+            excludedScopes = Set.of("test");
+        } else if (mode.equalsIgnoreCase("prod") || mode.isEmpty()) {
+            excludedScopes = Set.of("test", "provided");
+        } else {
+            throw new IllegalArgumentException(
+                    "Unrecognized mode '" + mode + "', supported values are test, dev, development, prod");
+        }
+
         final DependencyNode root;
         try {
-            root = resolver.collectDependencies(pom, List.of()).getRoot();
+            root = resolver.getSystem().collectDependencies(
+                    resolver.getSession(),
+                    resolver.newCollectManagedRequest(pom, List.of(), List.of(), List.of(), List.of(), excludedScopes))
+                    .getRoot();
         } catch (Exception e) {
             throw new MojoExecutionException("Failed to collect dependencies of " + pom, e);
         }
 
-        final List<Path> createdDirs = new ArrayList<>();
+        final LocalWorkspace workspace = resolver.getMavenContext().getWorkspace();
+        final List<Path> createdDirs = new ArrayList<>(workspace.getProjects().size());
         try {
-            ensureResolvableModule(root, resolver.getMavenContext().getWorkspace(), createdDirs);
-            final ArtifactCoords appArtifact = ArtifactCoords.of(pom.getGroupId(), pom.getArtifactId(), pom.getClassifier(),
-                    pom.getExtension(), pom.getVersion());
-            resolveAppModel(resolver, appArtifact, LaunchMode.NORMAL);
-            resolveAppModel(resolver, appArtifact, LaunchMode.DEVELOPMENT);
-            resolveAppModel(resolver, appArtifact, LaunchMode.TEST);
+            ensureResolvableModule(root, workspace, createdDirs);
+            appModelResolver.resolveModel(ArtifactCoords.of(pom.getGroupId(), pom.getArtifactId(), pom.getClassifier(),
+                    pom.getExtension(), pom.getVersion()));
+        } catch (AppModelResolverException e) {
+            throw new MojoExecutionException("Failed to resolve Quarkus application model for " + project.getArtifact(), e);
         } finally {
             for (Path d : createdDirs) {
                 IoUtils.recursiveDelete(d);
             }
         }
     }
 
-    private void resolveAppModel(final MavenArtifactResolver resolver, final ArtifactCoords appArtifact, LaunchMode mode)
-            throws MojoExecutionException {
-        final BootstrapAppModelResolver appModelResolver = new BootstrapAppModelResolver(resolver);
-        if (mode == LaunchMode.DEVELOPMENT) {
-            appModelResolver.setDevMode(true);
-        } else if (mode == LaunchMode.TEST) {
-            appModelResolver.setTest(true);
-        }
-        try {
-            appModelResolver.resolveModel(appArtifact);
-        } catch (AppModelResolverException e) {
-            throw new MojoExecutionException("Failed to resolve Quarkus application model for " + project.getArtifact(), e);
-        }
-    }
-
     private MavenArtifactResolver getResolver() throws MojoExecutionException {
         try {
             return MavenArtifactResolver.builder()
@@ -118,7 +132,12 @@ private static void ensureResolvableModule(DependencyNode node, LocalWorkspace w
         if (artifact != null) {
             final LocalProject module = workspace.getProject(artifact.getGroupId(), artifact.getArtifactId());
             if (module != null && !module.getRawModel().getPackaging().equals(ArtifactCoords.TYPE_POM)) {
-                final Path classesDir = module.getClassesDir();
+                final Path classesDir;
+                if (artifact.getClassifier().equals(ArtifactSources.TEST)) {
+                    classesDir = module.getTestClassesDir();
+                } else {
+                    classesDir = module.getClassesDir();
+                }
                 if (!Files.exists(classesDir)) {
                     Path topDirToCreate = classesDir;
                     while (!Files.exists(topDirToCreate.getParent())) {

devtools/maven/src/main/java/io/quarkus/maven/QuarkusBootstrapProvider.java

@@ -71,8 +71,11 @@ static Map<Path, Model> getProjectMap(MavenSession session) {
         }
         final Map<Path, Model> projectModels = new HashMap<>(allProjects.size());
         for (MavenProject mp : allProjects) {
-            mp.getOriginalModel().setPomFile(mp.getFile());
-            projectModels.put(mp.getBasedir().toPath(), mp.getOriginalModel());
+            final Model model = mp.getOriginalModel();
+            model.setPomFile(mp.getFile());
+            // activated profiles or custom extensions may have overridden the build defaults
+            model.setBuild(mp.getModel().getBuild());
+            projectModels.put(mp.getBasedir().toPath(), model);
         }
         return projectModels;
     }

docs/src/main/asciidoc/amazon-snapstart.adoc

@@ -22,7 +22,7 @@ However, you can enable/disable it explicitly using:
 
 [source, properties]
 ----
-quarkus.snapstart.enabled=true|false
+quarkus.snapstart.enable=true|false
 ----
 
 IMPORTANT: It does not enable/disable SnapStart for your function, only the Quarkus optimizations.

extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/ConfigBuildStep.java

@@ -299,8 +299,17 @@ void registerConfigMappingsBean(
             return;
         }
 
-        Map<Type, ConfigClassBuildItem> configMappingTypes = configClassesToTypesMap(configClasses, MAPPING);
         Set<ConfigClassBuildItem> configMappings = new HashSet<>();
+
+        // Add beans for all unremovable mappings
+        for (ConfigClassBuildItem configClass : configClasses) {
+            if (configClass.getConfigClass().isAnnotationPresent(Unremovable.class)) {
+                configMappings.add(configClass);
+            }
+        }
+
+        // Add beans for all injection points
+        Map<Type, ConfigClassBuildItem> configMappingTypes = configClassesToTypesMap(configClasses, MAPPING);
         for (InjectionPointInfo injectionPoint : beanRegistration.getInjectionPoints()) {
             Type type = Type.create(injectionPoint.getRequiredType().name(), Type.Kind.CLASS);
             ConfigClassBuildItem configClass = configMappingTypes.get(type);
@@ -309,6 +318,7 @@ void registerConfigMappingsBean(
             }
         }
 
+        // Generate the mappings beans
         for (ConfigClassBuildItem configClass : configMappings) {
             BeanConfigurator<Object> bean = beanRegistration.getContext()
                     .configure(configClass.getConfigClass())

extensions/arc/deployment/src/test/java/io/quarkus/arc/test/config/UnremovedConfigMappingTest.java

@@ -3,8 +3,10 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
+import javax.enterprise.inject.spi.CDI;
 import javax.inject.Inject;
 
+import org.eclipse.microprofile.config.inject.ConfigProperties;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
@@ -29,6 +31,12 @@ public class UnremovedConfigMappingTest {
     void unremoved() {
         UnremovedConfigMapping mapping = config.getConfigMapping(UnremovedConfigMapping.class);
         assertEquals("1234", mapping.prop());
+
+        mapping = CDI.current().select(UnremovedConfigMapping.class).get();
+        assertEquals("1234", mapping.prop());
+
+        UnremovedConfigProperties properties = CDI.current().select(UnremovedConfigProperties.class).get();
+        assertEquals("1234", properties.prop);
     }
 
     @Test
@@ -54,4 +62,10 @@ public interface ExtendsBase extends Base {
         @WithDefault("default")
         String myProp();
     }
+
+    @Unremovable
+    @ConfigProperties(prefix = "mapping")
+    public static class UnremovedConfigProperties {
+        String prop;
+    }
 }

extensions/csrf-reactive/runtime/src/main/java/io/quarkus/csrf/reactive/runtime/CsrfRequestResponseReactiveFilter.java

@@ -179,16 +179,18 @@ && getCookieToken(routing, config) == null) {
                 byte[] csrfTokenBytes = (byte[]) routing.get(CSRF_TOKEN_BYTES_KEY);
 
                 if (csrfTokenBytes == null) {
-                    throw new IllegalStateException(
-                            "CSRF Filter should have set the property " + CSRF_TOKEN_KEY + ", but it is null");
+                    LOG.debug("CSRF Request Filter did not set the property " + CSRF_TOKEN_BYTES_KEY
+                            + ", no CSRF cookie will be created");
+                    return;
                 }
                 cookieValue = CsrfTokenUtils.signCsrfToken(csrfTokenBytes, config.tokenSignatureKey.get());
             } else {
                 String csrfToken = (String) routing.get(CSRF_TOKEN_KEY);
 
                 if (csrfToken == null) {
-                    throw new IllegalStateException(
-                            "CSRF Filter should have set the property " + CSRF_TOKEN_KEY + ", but it is null");
+                    LOG.debug("CSRF Request Filter did not set the property " + CSRF_TOKEN_KEY
+                            + ", no CSRF cookie will be created");
+                    return;
                 }
                 cookieValue = csrfToken;
             }