Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add support for Java Toolchains in Quarkus Gradle plugin #44392

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Add support for Java Toolchains in Quarkus Gradle plugin #44392

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
041d43d
feat: support for Java Toolchains in Quarkus Gradle plugin
joschi Nov 8, 2024
f672ef4
Code formatting
joschi Nov 29, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
15 changes: 15 additions & 0 deletions devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/GradleUtils.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,13 @@
import org.gradle.api.artifacts.Dependency;
import org.gradle.api.artifacts.ModuleDependency;
import org.gradle.api.attributes.Category;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.gradle.jvm.toolchain.internal.SpecificInstallationToolchainSpec;
import org.gradle.process.internal.DefaultJavaExecSpec;

import javax.annotation.Nullable;

public class GradleUtils {

Expand Down Expand Up @@ -58,4 +64,13 @@ public static List<Dependency> listProjectBoms(Project project) {
return boms;
}

@Nullable
public static JavaToolchainSpec getExecutableOverrideToolchainSpec(ObjectFactory objectFactory) {
String customExecutable = objectFactory.newInstance(DefaultJavaExecSpec.class).getExecutable();
Copy link
Contributor

@asodja asodja Dec 2, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Just passing by:
JavaExec is doing that because for JavaExec you can set java as executable. For your task that doesn't make a lot of sense and objectFactory.newInstance(DefaultJavaExecSpec.class).getExecutable(); will always return null anyway. Also you are referencing internal type, it would be great if you could avoid that :)

I assume you want to achieve logic like:

if (quarkusTask has set toolchain) {
   use that
} else {
  use toolchains from JavaExtension
}

You can achieve that with something like:

Provider<JavaLauncher> javaExtensionToolchainLauncher = getToolchainService().launcherFor(getJavaPluginExtension().getToolchain());
task.getJavaLauncher().convention(javaExtensionToolchainLauncher);

See also https://docs.gradle.org/current/userguide/toolchains.html#sec:plugins_toolchains

I hope that helps! 👋

if (customExecutable != null) {
return SpecificInstallationToolchainSpec.fromJavaExecutable(objectFactory, customExecutable);
}

return null;
}
}
31 changes: 27 additions & 4 deletions devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/QuarkusPlugin.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.stream.Collectors;

import javax.inject.Inject;
Expand All @@ -26,6 +27,7 @@
import org.gradle.api.file.FileCollection;
import org.gradle.api.plugins.BasePlugin;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.Provider;
import org.gradle.api.specs.Spec;
Expand All @@ -35,6 +37,8 @@
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.testing.Test;
import org.gradle.jvm.toolchain.JavaToolchainService;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry;
import org.gradle.util.GradleVersion;

Expand Down Expand Up @@ -208,21 +212,22 @@ private void registerTasks(Project project, QuarkusPluginExtension quarkusExt) {
// quarkusGenerateCode
TaskProvider<QuarkusGenerateCode> quarkusGenerateCode = tasks.register(QUARKUS_GENERATE_CODE_TASK_NAME,
QuarkusGenerateCode.class, LaunchMode.NORMAL, SourceSet.MAIN_SOURCE_SET_NAME);
quarkusGenerateCode.configure(task -> configureGenerateCodeTask(task, quarkusGenerateAppModelTask,
quarkusGenerateCode.configure(task -> configureGenerateCodeTask(project, task, quarkusGenerateAppModelTask,
QuarkusGenerateCode.QUARKUS_GENERATED_SOURCES));
// quarkusGenerateCodeDev
TaskProvider<QuarkusGenerateCode> quarkusGenerateCodeDev = tasks.register(QUARKUS_GENERATE_CODE_DEV_TASK_NAME,
QuarkusGenerateCode.class, LaunchMode.DEVELOPMENT, SourceSet.MAIN_SOURCE_SET_NAME);
quarkusGenerateCodeDev.configure(task -> {
task.dependsOn(quarkusGenerateCode);
configureGenerateCodeTask(task, quarkusGenerateDevAppModelTask, QuarkusGenerateCode.QUARKUS_GENERATED_SOURCES);
configureGenerateCodeTask(project, task, quarkusGenerateDevAppModelTask,
QuarkusGenerateCode.QUARKUS_GENERATED_SOURCES);
});
// quarkusGenerateCodeTests
TaskProvider<QuarkusGenerateCode> quarkusGenerateCodeTests = tasks.register(QUARKUS_GENERATE_CODE_TESTS_TASK_NAME,
QuarkusGenerateCode.class, LaunchMode.TEST, SourceSet.TEST_SOURCE_SET_NAME);
quarkusGenerateCodeTests.configure(task -> {
task.dependsOn("compileQuarkusTestGeneratedSourcesJava");
configureGenerateCodeTask(task, quarkusGenerateTestAppModelTask,
configureGenerateCodeTask(project, task, quarkusGenerateTestAppModelTask,
QuarkusGenerateCode.QUARKUS_TEST_GENERATED_SOURCES);
});

Expand Down Expand Up @@ -522,9 +527,23 @@ private static void configureQuarkusBuildTask(Project project, QuarkusBuildTask
task.setCompileClasspath(mainSourceSet.getCompileClasspath().plus(mainSourceSet.getRuntimeClasspath())
.plus(mainSourceSet.getAnnotationProcessorPath())
.plus(mainSourceSet.getResources()));

Provider<JavaToolchainSpec> toolchainOverrideSpec = project
.provider(() -> GradleUtils.getExecutableOverrideToolchainSpec(project.getObjects()));
task.getJavaLauncher().convention(getToolchainTool(project, JavaToolchainService::launcherFor, toolchainOverrideSpec));
}

private static <T> Provider<T> getToolchainTool(
Project project,
BiFunction<JavaToolchainService, JavaToolchainSpec, Provider<T>> toolMapper,
Provider<JavaToolchainSpec> toolchainOverride) {
JavaToolchainService service = project.getExtensions().getByType(JavaToolchainService.class);
JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
return toolchainOverride.orElse(extension.getToolchain())
.flatMap(spec -> toolMapper.apply(service, spec));
}

private static void configureGenerateCodeTask(QuarkusGenerateCode task,
private static void configureGenerateCodeTask(Project project, QuarkusGenerateCode task,
TaskProvider<QuarkusApplicationModelTask> applicationModelTaskTaskProvider, String generateSourcesDir) {
SourceSet generatedSources = getSourceSet(task.getProject(), generateSourcesDir);
Set<File> sourceSetOutput = generatedSources.getOutput().filter(f -> f.getName().equals(generateSourcesDir)).getFiles();
Expand All @@ -535,6 +554,10 @@ private static void configureGenerateCodeTask(QuarkusGenerateCode task,
task.getApplicationModel()
.set(applicationModelTaskTaskProvider.flatMap(QuarkusApplicationModelTask::getApplicationModel));
task.getGeneratedOutputDirectory().set(generatedSources.getJava().getClassesDirectory());

Provider<JavaToolchainSpec> toolchainOverrideSpec = project
.provider(() -> GradleUtils.getExecutableOverrideToolchainSpec(project.getObjects()));
task.getJavaLauncher().convention(getToolchainTool(project, JavaToolchainService::launcherFor, toolchainOverrideSpec));
}

private void createSourceSets(Project project) {
Expand Down
40 changes: 38 additions & 2 deletions ...s/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/tasks/QuarkusTask.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,8 +8,16 @@

import javax.inject.Inject;

import io.quarkus.gradle.GradleUtils;
import org.gradle.api.Action;
import org.gradle.api.DefaultTask;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.tasks.Nested;
import org.gradle.jvm.toolchain.JavaLauncher;
import org.gradle.jvm.toolchain.JavaToolchainService;
import org.gradle.process.JavaForkOptions;
import org.gradle.workers.ProcessWorkerSpec;
import org.gradle.workers.WorkQueue;
Expand All @@ -24,6 +32,7 @@ public abstract class QuarkusTask extends DefaultTask {
private final transient QuarkusPluginExtension extension;
protected final File projectDir;
protected final File buildDir;
private final Property<JavaLauncher> javaLauncher;

QuarkusTask(String description) {
this(description, false);
Expand All @@ -36,16 +45,39 @@ public abstract class QuarkusTask extends DefaultTask {
this.projectDir = getProject().getProjectDir();
this.buildDir = getProject().getBuildDir();

ObjectFactory objectFactory = getObjectFactory();
JavaToolchainService javaToolchainService = getJavaToolchainService();
Provider<JavaLauncher> javaLauncherConvention = getProviderFactory()
.provider(() -> GradleUtils.getExecutableOverrideToolchainSpec(objectFactory))
.flatMap(javaToolchainService::launcherFor)
.orElse(javaToolchainService.launcherFor(it -> {
}));
this.javaLauncher = objectFactory.property(JavaLauncher.class).convention(javaLauncherConvention);

// Calling this method tells Gradle that it should not fail the build. Side effect is that the configuration
// cache will be at least degraded, but the build will not fail.
if (!configurationCacheCompatible) {
notCompatibleWithConfigurationCache("The Quarkus Plugin isn't compatible with the configuration cache");
}
}

@Inject
protected abstract ObjectFactory getObjectFactory();

@Inject
protected abstract ProviderFactory getProviderFactory();

@Inject
protected abstract JavaToolchainService getJavaToolchainService();

@Inject
protected abstract WorkerExecutor getWorkerExecutor();

@Nested
public Property<JavaLauncher> getJavaLauncher() {
return javaLauncher;
}

QuarkusPluginExtension extension() {
return extension;
}
Expand All @@ -60,14 +92,18 @@ WorkQueue workQueue(Map<String, String> configMap, List<Action<? super JavaForkO
}

return workerExecutor.processIsolation(processWorkerSpec -> configureProcessWorkerSpec(processWorkerSpec,
configMap, forkOptionsSupplier));
configMap, forkOptionsSupplier, getJavaLauncher().get()));
Copy link
Contributor

@asodja asodja Dec 2, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Calling .get() will throw exeption if value is null. But launcher here will never be null, since it's not marked as @Optional. And if user sets it to null (they need to also unset convention on the property) then this task will fail already at validation.

What I am trying to say is: It seems in this case you don't need to check launcher != null later on, unless you mark getJavaLauncher() as @Optional @Nested, but then you also need to call .getOrNull() here. But I think it makes more sense that getJavaLauncher() is not allowed to be null and with that you can remove null check later on

}

private void configureProcessWorkerSpec(ProcessWorkerSpec processWorkerSpec, Map<String, String> configMap,
List<Action<? super JavaForkOptions>> customizations) {
List<Action<? super JavaForkOptions>> customizations, JavaLauncher launcher) {
JavaForkOptions forkOptions = processWorkerSpec.getForkOptions();
customizations.forEach(a -> a.execute(forkOptions));

if (launcher != null) {
forkOptions.executable(launcher.getExecutablePath().getAsFile().getAbsolutePath());
}

// Propagate user.dir to load config sources that use it (instead of the worker user.dir)
String userDir = configMap.get("user.dir");
if (userDir != null) {
Expand Down
64 changes: 64 additions & 0 deletions ...le/gradle-application-plugin/src/test/java/io/quarkus/gradle/tasks/JavaToolchainTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,64 @@
package io.quarkus.gradle.tasks;

import org.apache.commons.io.FileUtils;
import org.gradle.testkit.runner.BuildResult;
import org.gradle.testkit.runner.GradleRunner;
import org.gradle.testkit.runner.TaskOutcome;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

import java.io.File;
import java.net.URL;
import java.nio.file.Path;

import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;

public class JavaToolchainTest {

@TempDir
Path testProjectDir;

@Test
void quarkusIsUsingJavaToolchain() throws Exception {
URL url = getClass().getClassLoader().getResource("io/quarkus/gradle/tasks/toolchain/main");
FileUtils.copyDirectory(new File(url.toURI()), testProjectDir.toFile());
FileUtils.copyFile(new File("../gradle.properties"), testProjectDir.resolve("gradle.properties").toFile());

GradleRunner.create()
.withPluginClasspath()
.withProjectDir(testProjectDir.toFile())
.withArguments("build", "--info", "--stacktrace", "--build-cache", "--configuration-cache")
// .build() checks whether the build failed, which is good enough for this test
.build();
}

@Test
void quarkusPluginCanOverrideJavaToolchain() throws Exception {
URL url = getClass().getClassLoader().getResource("io/quarkus/gradle/tasks/toolchain/custom");
FileUtils.copyDirectory(new File(url.toURI()), testProjectDir.toFile());
FileUtils.copyFile(new File("../gradle.properties"), testProjectDir.resolve("gradle.properties").toFile());

GradleRunner.create()
.withPluginClasspath()
.withProjectDir(testProjectDir.toFile())
.withArguments("build", "--info", "--stacktrace", "--build-cache", "--configuration-cache")
// .build() checks whether the build failed, which is good enough for this test
.build();
}

@Test
void quarkusPluginFailsWithIncompatibleToolchains() throws Exception {
URL url = getClass().getClassLoader().getResource("io/quarkus/gradle/tasks/toolchain/fail");
FileUtils.copyDirectory(new File(url.toURI()), testProjectDir.toFile());
FileUtils.copyFile(new File("../gradle.properties"), testProjectDir.resolve("gradle.properties").toFile());

BuildResult buildResult = GradleRunner.create()
.withPluginClasspath()
.withProjectDir(testProjectDir.toFile())
.withArguments("build", "--info", "--stacktrace", "--build-cache", "--configuration-cache")
.buildAndFail();

assertThat(buildResult.task(":quarkusAppPartsBuild").getOutcome()).isEqualTo(TaskOutcome.FAILED);
assertThat(buildResult.getOutput()).contains("java.lang.UnsupportedClassVersionError");
}
}
35 changes: 35 additions & 0 deletions ...ation-plugin/src/test/resources/io/quarkus/gradle/tasks/toolchain/custom/build.gradle.kts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,35 @@
plugins {
java
id("io.quarkus")
}

buildscript {
repositories {
mavenLocal()
mavenCentral()
}
}

repositories {
mavenLocal()
mavenCentral()
}

dependencies {
implementation(enforcedPlatform("io.quarkus:quarkus-bom:${project.property("version")}"))
implementation("io.quarkus:quarkus-core")
implementation("jakarta.inject:jakarta.inject-api:2.0.1")
}

java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}

tasks.withType(io.quarkus.gradle.tasks.QuarkusTask::class.java) {
javaLauncher = javaToolchains.launcherFor {
languageVersion = JavaLanguageVersion.of(21)
}

}
5 changes: 5 additions & 0 deletions ...on-plugin/src/test/resources/io/quarkus/gradle/tasks/toolchain/custom/settings.gradle.kts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,5 @@
plugins {
id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
}

rootProject.name = "gradle-java-toolchain"
8 changes: 8 additions & 0 deletions ...c/test/resources/io/quarkus/gradle/tasks/toolchain/custom/src/main/java/org/acme/Foo.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,8 @@
package org.acme;

import io.smallrye.config.ConfigMapping;

@ConfigMapping(prefix = "foo")
public interface Foo {
String string();
}
35 changes: 35 additions & 0 deletions ...ication-plugin/src/test/resources/io/quarkus/gradle/tasks/toolchain/fail/build.gradle.kts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,35 @@
plugins {
java
id("io.quarkus")
}

buildscript {
repositories {
mavenLocal()
mavenCentral()
}
}

repositories {
mavenLocal()
mavenCentral()
}

dependencies {
implementation(enforcedPlatform("io.quarkus:quarkus-bom:${project.property("version")}"))
implementation("io.quarkus:quarkus-core")
implementation("jakarta.inject:jakarta.inject-api:2.0.1")
}

java {
toolchain {
languageVersion = JavaLanguageVersion.of(21)
}
}

tasks.withType(io.quarkus.gradle.tasks.QuarkusTask::class.java) {
javaLauncher = javaToolchains.launcherFor {
languageVersion = JavaLanguageVersion.of(17)
}

}
5 changes: 5 additions & 0 deletions ...tion-plugin/src/test/resources/io/quarkus/gradle/tasks/toolchain/fail/settings.gradle.kts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,5 @@
plugins {
id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
}

rootProject.name = "gradle-java-toolchain"
8 changes: 8 additions & 0 deletions ...src/test/resources/io/quarkus/gradle/tasks/toolchain/fail/src/main/java/org/acme/Foo.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,8 @@
package org.acme;

import io.smallrye.config.ConfigMapping;

@ConfigMapping(prefix = "foo")
public interface Foo {
String string();
}
Loading
Loading