Configurable java toolchains

.gitignore

@@ -16,3 +16,5 @@ out/
 docs/node_modules/
 generated_src
 generated_testSrc
+generated
+generated_tests

changelog/@unreleased/pr-2193.v2.yml

@@ -0,0 +1,6 @@
+type: feature
+feature:
+  description: Add a configuration point for providing your own JDKs to all java requiring
+    tasks.
+  links:
+  - https://github.com/palantir/gradle-baseline/pull/2193

gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java

@@ -18,18 +18,20 @@
 
 import javax.inject.Inject;
 import org.gradle.api.Project;
+import org.gradle.api.provider.MapProperty;
 import org.gradle.api.provider.Property;
+import org.gradle.jvm.toolchain.JavaInstallationMetadata;
 import org.gradle.jvm.toolchain.JavaLanguageVersion;
 
 /**
  * Extension named {@code javaVersions} on the root project used to configure all java modules
  * with consistent java toolchains.
  */
 public class BaselineJavaVersionsExtension {
-
     private final Property<JavaLanguageVersion> libraryTarget;
     private final Property<JavaLanguageVersion> distributionTarget;
     private final Property<JavaLanguageVersion> runtime;
+    private final MapProperty<JavaLanguageVersion, JavaInstallationMetadata> jdks;
 
     @Inject
     public BaselineJavaVersionsExtension(Project project) {
@@ -43,6 +45,9 @@ public BaselineJavaVersionsExtension(Project project) {
         libraryTarget.finalizeValueOnRead();
         distributionTarget.finalizeValueOnRead();
         runtime.finalizeValueOnRead();
+
+        jdks = project.getObjects().mapProperty(JavaLanguageVersion.class, JavaInstallationMetadata.class);
+        jdks.finalizeValueOnRead();
     }
 
     /** Target {@link JavaLanguageVersion} for compilation of libraries that are published. */
@@ -74,4 +79,8 @@ public final Property<JavaLanguageVersion> runtime() {
     public final void setRuntime(int value) {
         runtime.set(JavaLanguageVersion.of(value));
     }
+
+    public final MapProperty<JavaLanguageVersion, JavaInstallationMetadata> getJdks() {
+        return jdks;
+    }
 }

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java

@@ -17,6 +17,9 @@
 package com.palantir.baseline.plugins;
 
 import com.palantir.baseline.extensions.BaselineJavaVersionExtension;
+import com.palantir.baseline.extensions.BaselineJavaVersionsExtension;
+import com.palantir.baseline.plugins.javaversions.BaselineJavaToolchain;
+import com.palantir.baseline.plugins.javaversions.JavaToolchains;
 import javax.inject.Inject;
 import org.gradle.api.Action;
 import org.gradle.api.DefaultTask;
@@ -38,7 +41,6 @@
 import org.gradle.api.tasks.scala.ScalaDoc;
 import org.gradle.api.tasks.testing.Test;
 import org.gradle.jvm.toolchain.JavaLanguageVersion;
-import org.gradle.jvm.toolchain.JavaToolchainService;
 import org.gradle.jvm.toolchain.JavaToolchainSpec;
 
 public final class BaselineJavaVersion implements Plugin<Project> {
@@ -49,6 +51,7 @@ public final class BaselineJavaVersion implements Plugin<Project> {
     public void apply(Project project) {
         BaselineJavaVersionExtension extension =
                 project.getExtensions().create(EXTENSION_NAME, BaselineJavaVersionExtension.class, project);
+
         project.getPluginManager().withPlugin("java", unused -> {
             JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
 
@@ -62,11 +65,14 @@ public void execute(JavaToolchainSpec javaToolchainSpec) {
                 }
             });
 
+            JavaToolchains javaToolchains = new JavaToolchains(
+                    project, project.getRootProject().getExtensions().getByType(BaselineJavaVersionsExtension.class));
+
             // Compilation tasks (using target version)
-            configureCompilationTasks(project, extension.target());
+            configureCompilationTasks(project, extension.target(), javaToolchains.forVersion(extension.target()));
 
             // Execution tasks (using the runtime version)
-            configureExecutionTasks(project, extension.runtime());
+            configureExecutionTasks(project, javaToolchains.forVersion(extension.runtime()));
 
             // Validation
             project.getTasks()
@@ -82,18 +88,13 @@ public void execute(CheckJavaVersionsTask task) {
     }
 
     private static void configureCompilationTasks(
-            Project project, Provider<JavaLanguageVersion> targetVersionProvider) {
-        JavaToolchainService javaToolchainService = project.getExtensions().getByType(JavaToolchainService.class);
-
+            Project project,
+            Provider<JavaLanguageVersion> targetVersionProvider,
+            Provider<BaselineJavaToolchain> javaToolchain) {
         project.getTasks().withType(JavaCompile.class, new Action<JavaCompile>() {
             @Override
             public void execute(JavaCompile javaCompile) {
-                javaCompile.getJavaCompiler().set(javaToolchainService.compilerFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(targetVersionProvider);
-                    }
-                }));
+                javaCompile.getJavaCompiler().set(javaToolchain.flatMap(BaselineJavaToolchain::javaCompiler));
                 // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used.
                 javaCompile.doFirst(new Action<Task>() {
                     @Override
@@ -109,24 +110,14 @@ public void execute(Task task) {
         project.getTasks().withType(Javadoc.class, new Action<Javadoc>() {
             @Override
             public void execute(Javadoc javadoc) {
-                javadoc.getJavadocTool().set(javaToolchainService.javadocToolFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(targetVersionProvider);
-                    }
-                }));
+                javadoc.getJavadocTool().set(javaToolchain.flatMap(BaselineJavaToolchain::javadocTool));
             }
         });
 
         project.getTasks().withType(GroovyCompile.class, new Action<GroovyCompile>() {
             @Override
             public void execute(GroovyCompile groovyCompile) {
-                groovyCompile.getJavaLauncher().set(javaToolchainService.launcherFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(targetVersionProvider);
-                    }
-                }));
+                groovyCompile.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher));
                 // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used.
                 groovyCompile.doFirst(new Action<Task>() {
                     @Override
@@ -142,12 +133,7 @@ public void execute(Task task) {
         project.getTasks().withType(ScalaCompile.class, new Action<ScalaCompile>() {
             @Override
             public void execute(ScalaCompile scalaCompile) {
-                scalaCompile.getJavaLauncher().set(javaToolchainService.launcherFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(targetVersionProvider);
-                    }
-                }));
+                scalaCompile.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher));
                 // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used.
                 scalaCompile.doFirst(new Action<Task>() {
                     @Override
@@ -163,39 +149,23 @@ public void execute(Task task) {
         project.getTasks().withType(ScalaDoc.class, new Action<ScalaDoc>() {
             @Override
             public void execute(ScalaDoc scalaDoc) {
-                scalaDoc.getJavaLauncher().set(javaToolchainService.launcherFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(targetVersionProvider);
-                    }
-                }));
+                scalaDoc.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher));
             }
         });
     }
 
-    private static void configureExecutionTasks(Project project, Provider<JavaLanguageVersion> runtimeVersionProvider) {
-        JavaToolchainService javaToolchainService = project.getExtensions().getByType(JavaToolchainService.class);
+    private static void configureExecutionTasks(Project project, Provider<BaselineJavaToolchain> javaToolchain) {
         project.getTasks().withType(JavaExec.class, new Action<JavaExec>() {
             @Override
             public void execute(JavaExec javaExec) {
-                javaExec.getJavaLauncher().set(javaToolchainService.launcherFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(runtimeVersionProvider);
-                    }
-                }));
+                javaExec.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher));
             }
         });
 
         project.getTasks().withType(Test.class, new Action<Test>() {
             @Override
             public void execute(Test test) {
-                test.getJavaLauncher().set(javaToolchainService.launcherFor(new Action<JavaToolchainSpec>() {
-                    @Override
-                    public void execute(JavaToolchainSpec javaToolchainSpec) {
-                        javaToolchainSpec.getLanguageVersion().set(runtimeVersionProvider);
-                    }
-                }));
+                test.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher));
             }
         });
     }

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaCompiler.java

@@ -0,0 +1,39 @@
+/*
+ * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed 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
+ *
+ *     http://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 com.palantir.baseline.plugins.javaversions;
+
+import org.gradle.api.file.RegularFile;
+import org.gradle.jvm.toolchain.JavaCompiler;
+import org.gradle.jvm.toolchain.JavaInstallationMetadata;
+
+final class BaselineJavaCompiler implements JavaCompiler {
+    private final JavaInstallationMetadata javaInstallationMetadata;
+
+    BaselineJavaCompiler(JavaInstallationMetadata javaInstallationMetadata) {
+        this.javaInstallationMetadata = javaInstallationMetadata;
+    }
+
+    @Override
+    public JavaInstallationMetadata getMetadata() {
+        return javaInstallationMetadata;
+    }
+
+    @Override
+    public RegularFile getExecutablePath() {
+        return JavaInstallationMetadataUtils.findExecutable(javaInstallationMetadata, "javac");
+    }
+}

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaLauncher.java

@@ -0,0 +1,39 @@
+/*
+ * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed 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
+ *
+ *     http://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 com.palantir.baseline.plugins.javaversions;
+
+import org.gradle.api.file.RegularFile;
+import org.gradle.jvm.toolchain.JavaInstallationMetadata;
+import org.gradle.jvm.toolchain.JavaLauncher;
+
+final class BaselineJavaLauncher implements JavaLauncher {
+    private final JavaInstallationMetadata javaInstallationMetadata;
+
+    BaselineJavaLauncher(JavaInstallationMetadata javaInstallationMetadata) {
+        this.javaInstallationMetadata = javaInstallationMetadata;
+    }
+
+    @Override
+    public JavaInstallationMetadata getMetadata() {
+        return javaInstallationMetadata;
+    }
+
+    @Override
+    public RegularFile getExecutablePath() {
+        return JavaInstallationMetadataUtils.findExecutable(javaInstallationMetadata, "java");
+    }
+}

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaToolchain.java

@@ -0,0 +1,30 @@
+/*
+ * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed 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
+ *
+ *     http://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 com.palantir.baseline.plugins.javaversions;
+
+import org.gradle.api.provider.Provider;
+import org.gradle.jvm.toolchain.JavaCompiler;
+import org.gradle.jvm.toolchain.JavaLauncher;
+import org.gradle.jvm.toolchain.JavadocTool;
+
+public interface BaselineJavaToolchain {
+    Provider<JavaCompiler> javaCompiler();
+
+    Provider<JavadocTool> javadocTool();
+
+    Provider<JavaLauncher> javaLauncher();
+}

gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavadocTool.java

@@ -0,0 +1,39 @@
+/*
+ * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed 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
+ *
+ *     http://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 com.palantir.baseline.plugins.javaversions;
+
+import org.gradle.api.file.RegularFile;
+import org.gradle.jvm.toolchain.JavaInstallationMetadata;
+import org.gradle.jvm.toolchain.JavadocTool;
+
+final class BaselineJavadocTool implements JavadocTool {
+    private final JavaInstallationMetadata javaInstallationMetadata;
+
+    BaselineJavadocTool(JavaInstallationMetadata javaInstallationMetadata) {
+        this.javaInstallationMetadata = javaInstallationMetadata;
+    }
+
+    @Override
+    public JavaInstallationMetadata getMetadata() {
+        return javaInstallationMetadata;
+    }
+
+    @Override
+    public RegularFile getExecutablePath() {
+        return JavaInstallationMetadataUtils.findExecutable(javaInstallationMetadata, "javadoc");
+    }
+}