Merge branch 'main' into issue/48641

Author: RoMiRoSSaN

bom/application/pom.xml

@@ -165,7 +165,7 @@
         <!-- liquibase-mongodb is not released everytime with liquibase anymore, but the two versions need to be compatible -->
         <liquibase.version>4.33.0</liquibase.version>
         <liquibase-mongodb.version>4.33.0.1</liquibase-mongodb.version>
-        <snakeyaml.version>2.4</snakeyaml.version>
+        <snakeyaml.version>2.5</snakeyaml.version>
         <osgi.version>6.0.0</osgi.version>
         <mongo-client.version>5.5.1</mongo-client.version>
         <proton-j.version>0.34.1</proton-j.version>
@@ -4391,6 +4391,11 @@
                 <artifactId>smallrye-fault-tolerance-api</artifactId>
                 <version>${smallrye-fault-tolerance.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.smallrye</groupId>
+                <artifactId>smallrye-fault-tolerance-apiimpl</artifactId>
+                <version>${smallrye-fault-tolerance.version}</version>
+            </dependency>
             <dependency>
                 <groupId>io.smallrye</groupId>
                 <artifactId>smallrye-fault-tolerance-autoconfig-core</artifactId>
@@ -4416,6 +4421,11 @@
                 <artifactId>smallrye-fault-tolerance-mutiny</artifactId>
                 <version>${smallrye-fault-tolerance.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.smallrye</groupId>
+                <artifactId>smallrye-fault-tolerance-standalone</artifactId>
+                <version>${smallrye-fault-tolerance.version}</version>
+            </dependency>
             <dependency>
                 <groupId>io.smallrye</groupId>
                 <artifactId>smallrye-fault-tolerance-tracing-propagation</artifactId>

build-parent/pom.xml

@@ -21,6 +21,7 @@
         <!-- These properties are needed in order for them to be resolvable by the generated projects -->
         <compiler-plugin.version>${version.compiler.plugin}</compiler-plugin.version>
         <kotlin.version>2.2.10</kotlin.version>
+        <ksp-gradle-plugin.version>2.2.10-2.0.2</ksp-gradle-plugin.version> <!-- Kotlin Symbol Processing plugin used in a test -->
         <dokka.version>2.0.0</dokka.version>
         <scala.version>2.13.12</scala.version>
         <scala-maven-plugin.version>4.9.5</scala-maven-plugin.version>

core/deployment/src/main/java/io/quarkus/deployment/dev/DevModeMain.java

@@ -10,6 +10,7 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
+import java.nio.file.FileSystemException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -26,6 +27,7 @@
 import io.quarkus.dev.spi.DevModeType;
 import io.quarkus.maven.dependency.ArtifactKey;
 import io.quarkus.paths.PathList;
+import io.smallrye.common.os.OS;
 
 /**
  * The main entry point for the dev mojo execution
@@ -196,7 +198,18 @@ private void linkDotEnvFile() {
             silentDeleteFile(link);
             try {
                 // create a symlink to ensure that user updates to the file have the expected effect in dev-mode
-                Files.createSymbolicLink(link, dotEnvPath);
+                try {
+                    Files.createSymbolicLink(link, dotEnvPath);
+                } catch (FileSystemException e) {
+                    // on Windows fall back to hard link if symlink cannot be created (due to insufficient permissions)
+                    // see https://github.com/quarkusio/quarkus/issues/49785
+                    if (OS.WINDOWS.isCurrent()) {
+                        log.debug("Falling back to hard link on Windows after FileSystemException", e);
+                        Files.createLink(link, dotEnvPath);
+                    } else {
+                        throw e;
+                    }
+                }
             } catch (IOException e) {
                 log.warn("Unable to link .env file", e);
             }

core/deployment/src/main/java/io/quarkus/deployment/pkg/steps/NativeImageBuildContainerRunner.java

@@ -4,6 +4,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
@@ -22,6 +23,7 @@ public abstract class NativeImageBuildContainerRunner extends NativeImageBuildRu
     protected final ContainerRuntimeUtil.ContainerRuntime containerRuntime;
     String[] baseContainerRuntimeArgs;
     private final String containerName;
+    private final AtomicBoolean setupInvoked = new AtomicBoolean();
 
     protected NativeImageBuildContainerRunner(NativeConfig nativeConfig) {
         this.nativeConfig = nativeConfig;
@@ -39,7 +41,10 @@ public boolean isContainer() {
 
     @Override
     public void setup(boolean processInheritIODisabled) {
-        if (containerRuntime != ContainerRuntimeUtil.ContainerRuntime.UNAVAILABLE) {
+        if (containerRuntime == ContainerRuntimeUtil.ContainerRuntime.UNAVAILABLE) {
+            return;
+        }
+        if (setupInvoked.compareAndSet(false, true)) {
             log.infof("Using %s to run the native image builder", containerRuntime.getExecutableName());
             // we pull the docker image in order to give users an indication of which step the process is at
             // it's not strictly necessary we do this, however if we don't the subsequent version command
@@ -91,6 +96,7 @@ public void setup(boolean processInheritIODisabled) {
                 pull(effectiveBuilderImage, processInheritIODisabled);
             }
         }
+
     }
 
     private void pull(String effectiveBuilderImage, boolean processInheritIODisabled) {

core/runtime/src/main/java/io/quarkus/runtime/ApplicationLifecycleManager.java

@@ -164,8 +164,8 @@ public static void run(Application application, Class<? extends QuarkusApplicati
                     stateLock.unlock();
                 }
             }
-        } catch (Exception e) {
-            Throwable rootCause = ExceptionUtil.getRootCause(e);
+        } catch (Throwable t) {
+            Throwable rootCause = ExceptionUtil.getRootCause(t);
             if (exitCodeHandler == null) {
                 Logger applicationLogger = Logger.getLogger(Application.class);
                 if (rootCause instanceof QuarkusBindException qbe) {
@@ -198,7 +198,7 @@ public static void run(Application application, Class<? extends QuarkusApplicati
                         && !StringUtil.isNullOrEmpty(rootCause.getMessage())) {
                     System.err.println(rootCause.getMessage());
                 } else {
-                    applicationLogger.errorv(e, "Failed to start application");
+                    applicationLogger.errorv(t, "Failed to start application");
                     ensureConsoleLogsDrained();
                 }
             }
@@ -214,7 +214,7 @@ public static void run(Application application, Class<? extends QuarkusApplicati
                     ? ((PreventFurtherStepsException) rootCause).getExitCode()
                     : 1;
             currentApplication = null;
-            (exitCodeHandler == null ? defaultExitCodeHandler : exitCodeHandler).accept(exceptionExitCode, e);
+            (exitCodeHandler == null ? defaultExitCodeHandler : exitCodeHandler).accept(exceptionExitCode, t);
             return;
         } finally {
             try {

devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/QuarkusPlugin.java

@@ -7,6 +7,7 @@
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -348,43 +349,36 @@ public boolean isSatisfiedBy(Task t) {
 
                     project.afterEvaluate(this::afterEvaluate);
 
-                    tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile.class,
-                            compileJava -> {
-                                compileJava.mustRunAfter(quarkusGenerateCode);
-                                compileJava.mustRunAfter(quarkusGenerateCodeDev);
-                            });
-                    tasks.named(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME, JavaCompile.class,
-                            compileTestJava -> {
-                                compileTestJava.dependsOn(quarkusGenerateCode);
-                                compileTestJava.dependsOn(quarkusGenerateCodeTests);
-                                if (project.getGradle().getStartParameter().getTaskNames().contains(QUARKUS_DEV_TASK_NAME)) {
-                                    compileTestJava.getOptions().setFailOnError(false);
-                                }
-                            });
-
                     TaskProvider<Task> classesTask = tasks.named(JavaPlugin.CLASSES_TASK_NAME);
                     TaskProvider<Task> resourcesTask = tasks.named(JavaPlugin.PROCESS_RESOURCES_TASK_NAME);
                     TaskProvider<Task> testClassesTask = tasks.named(JavaPlugin.TEST_CLASSES_TASK_NAME);
                     TaskProvider<Task> testResourcesTask = tasks.named(JavaPlugin.PROCESS_TEST_RESOURCES_TASK_NAME);
 
+                    SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
+                    SourceSet mainSourceSet = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
+                    SourceSet testSourceSet = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
+
                     quarkusGenerateCode.configure(task -> {
                         Configuration config = project.getConfigurations().getByName(
                                 ApplicationDeploymentClasspathBuilder.getBaseRuntimeConfigName(LaunchMode.NORMAL));
                         task.dependsOn(resourcesTask, config);
                         task.setCompileClasspath(config);
+                        task.setSourcesDirectories(getSourcesParents(mainSourceSet));
                     });
                     quarkusGenerateCodeDev.configure(task -> {
                         Configuration config = project.getConfigurations().getByName(
                                 ApplicationDeploymentClasspathBuilder
                                         .getBaseRuntimeConfigName(LaunchMode.DEVELOPMENT));
                         task.dependsOn(resourcesTask, config);
                         task.setCompileClasspath(config);
+                        task.setSourcesDirectories(getSourcesParents(mainSourceSet));
                     });
                     quarkusGenerateCodeTests.configure(task -> {
                         Configuration config = project.getConfigurations().getByName(
                                 ApplicationDeploymentClasspathBuilder.getBaseRuntimeConfigName(LaunchMode.TEST));
                         task.dependsOn(resourcesTask, config);
                         task.setCompileClasspath(config);
+                        task.setSourcesDirectories(getSourcesParents(testSourceSet));
                     });
 
                     quarkusDev.configure(task -> {
@@ -403,18 +397,6 @@ public boolean isSatisfiedBy(Task t) {
                     quarkusBuildCacheableAppParts.configure(
                             task -> task.dependsOn(classesTask, resourcesTask, tasks.named(JavaPlugin.JAR_TASK_NAME)));
 
-                    SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
-
-                    SourceSet mainSourceSet = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
-                    SourceSet testSourceSet = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
-
-                    mainSourceSet.getJava().srcDirs(quarkusGenerateCode, quarkusGenerateCodeDev);
-                    testSourceSet.getJava().srcDirs(quarkusGenerateCodeTests);
-
-                    quarkusGenerateCode.configure(task -> task.setSourcesDirectories(getSourcesParents(mainSourceSet)));
-                    quarkusGenerateCodeDev.configure(task -> task.setSourcesDirectories(getSourcesParents(mainSourceSet)));
-                    quarkusGenerateCodeTests.configure(task -> task.setSourcesDirectories(getSourcesParents(testSourceSet)));
-
                     SourceSet intTestSourceSet = sourceSets.getByName(INTEGRATION_TEST_SOURCE_SET_NAME);
                     intTestSourceSet.setCompileClasspath(
                             intTestSourceSet.getCompileClasspath()
@@ -487,32 +469,69 @@ public boolean isSatisfiedBy(Task t) {
                     // quarkusBuild is expected to run after the project has passed the tests
                     quarkusBuildCacheableAppParts.configure(task -> task.shouldRunAfter(tasks.withType(Test.class)));
 
-                    SourceSet generatedSourceSet = sourceSets.getByName(QuarkusGenerateCode.QUARKUS_GENERATED_SOURCES);
-                    SourceSet generatedTestSourceSet = sourceSets.getByName(QuarkusGenerateCode.QUARKUS_TEST_GENERATED_SOURCES);
-
-                    project.afterEvaluate(project1 -> {
-                        // Register the quarkus-generated-code
-                        for (String provider : quarkusExt.getCodeGenerationProviders().get()) {
-
-                            mainSourceSet.getJava().srcDir(
-                                    new File(generatedSourceSet.getJava().getClassesDirectory().get().getAsFile(), provider));
-                            testSourceSet.getJava().srcDir(
-                                    new File(generatedTestSourceSet.getJava().getClassesDirectory().get().getAsFile(),
-                                            provider));
-                        }
-                    });
+                    tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile.class,
+                            compileJava -> {
+                                // quarkusGenerateCode is a dependency
+                                compileJava.dependsOn(quarkusGenerateCode);
+                                // quarkusGenerateCodeDev must run before compileJava in case quarkusDev is the target
+                                compileJava.mustRunAfter(quarkusGenerateCodeDev);
+                                // add the code gen sources
+                                addCodeGenSourceDirs(compileJava,
+                                        sourceSets.getByName(QuarkusGenerateCode.QUARKUS_GENERATED_SOURCES), quarkusExt);
+                            });
+                    tasks.named(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME, JavaCompile.class,
+                            compileTestJava -> {
+                                compileTestJava.dependsOn(quarkusGenerateCode);
+                                compileTestJava.dependsOn(quarkusGenerateCodeTests);
+                                if (project.getGradle().getStartParameter().getTaskNames().contains(QUARKUS_DEV_TASK_NAME)) {
+                                    compileTestJava.getOptions().setFailOnError(false);
+                                }
+                                // add the code gen test sources
+                                addCodeGenSourceDirs(compileTestJava,
+                                        sourceSets.getByName(QuarkusGenerateCode.QUARKUS_TEST_GENERATED_SOURCES), quarkusExt);
+                            });
                 });
 
         project.getPlugins().withId("org.jetbrains.kotlin.jvm", plugin -> {
             quarkusDev.configure(task -> task.shouldPropagateJavaCompilerArgs(false));
             tasks.named("compileKotlin", task -> {
                 task.mustRunAfter(quarkusGenerateCode);
                 task.mustRunAfter(quarkusGenerateCodeDev);
+                addCodeGenSourceDirs(task, project.getExtensions().getByType(SourceSetContainer.class)
+                        .getByName(QuarkusGenerateCode.QUARKUS_GENERATED_SOURCES), quarkusExt);
+            });
+            tasks.named("compileTestKotlin", task -> {
+                task.dependsOn(quarkusGenerateCodeTests);
+                addCodeGenSourceDirs(task, project.getExtensions().getByType(SourceSetContainer.class)
+                        .getByName(QuarkusGenerateCode.QUARKUS_TEST_GENERATED_SOURCES), quarkusExt);
             });
-            tasks.named("compileTestKotlin", task -> task.dependsOn(quarkusGenerateCodeTests));
         });
     }
 
+    private static void addCodeGenSourceDirs(JavaCompile compileJava, SourceSet generatedSourceSet,
+            QuarkusPluginExtension quarkusExt) {
+        final File baseDir = generatedSourceSet.getJava().getClassesDirectory().get().getAsFile();
+        for (String provider : quarkusExt.getCodeGenerationProviders().get()) {
+            compileJava.source(new File(baseDir, provider));
+        }
+    }
+
+    private static void addCodeGenSourceDirs(Task compileKotlin, SourceSet generatedSourceSet,
+            QuarkusPluginExtension quarkusExt) {
+        final File baseDir = generatedSourceSet.getJava().getClassesDirectory().get().getAsFile();
+        final List<String> codeGenProviders = quarkusExt.getCodeGenerationProviders().get();
+        final Object[] codeGenDirs = new Object[codeGenProviders.size()];
+        for (int i = 0; i < codeGenDirs.length; ++i) {
+            codeGenDirs[i] = new File(baseDir, codeGenProviders.get(i));
+        }
+        try {
+            var sourcesMethod = compileKotlin.getClass().getMethod("source", Object[].class);
+            sourcesMethod.invoke(compileKotlin, new Object[] { codeGenDirs });
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     private ApplicationDeploymentClasspathBuilder getDeploymentClasspathBuilder(Project project, LaunchMode mode) {
         return new ApplicationDeploymentClasspathBuilder(project, mode, taskDependencyFactory);
     }

devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/tasks/EffectiveConfig.java

@@ -1,5 +1,6 @@
 package io.quarkus.gradle.tasks;
 
+import static io.smallrye.config.ConfigMappings.ConfigClass.configClass;
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
 import static java.util.Collections.unmodifiableMap;
@@ -140,6 +141,8 @@ public Map<String, String> get() {
                         properties.put(propertyName, configValue.getValue());
                     }
                 }
+                configClass(PackageConfig.class).getProperties().keySet().forEach(properties::remove);
+                configClass(NativeConfig.class).getProperties().keySet().forEach(properties::remove);
                 return unmodifiableMap(properties);
             }
         });