Configurable java toolchains

.gitignore

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

gradle-baseline-java/build.gradle

@@ -21,6 +21,7 @@ dependencies {
     implementation 'org.ow2.asm:asm'
     implementation 'com.googlecode.java-diff-utils:diffutils'
     implementation 'com.diffplug.gradle:goomph'
+    implementation 'org.rauschig:jarchivelib'
 
     runtimeOnly 'com.palantir.javaformat:gradle-palantir-java-format'
 

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

@@ -16,8 +16,13 @@
 
 package com.palantir.baseline.extensions;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 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.JavaLanguageVersion;
 
@@ -26,19 +31,33 @@
  * target and runtime java versions used for a single project.
  */
 public class BaselineJavaVersionExtension {
+    private static final Pattern ZULU_VERSION_PATTERN = Pattern.compile("ZULU_([\\d]+)_VERSION");
+    private static final Pattern JAVA_VERSION_PATTERN = Pattern.compile("JAVA_([\\d]+)_VERSION");
 
     private final Property<JavaLanguageVersion> target;
     private final Property<JavaLanguageVersion> runtime;
     private final Property<Boolean> overrideLibraryAutoDetection;
+    private final MapProperty<JavaLanguageVersion, String> zuluVersions;
+    private final MapProperty<JavaLanguageVersion, String> javaVersions;
 
     @Inject
     public BaselineJavaVersionExtension(Project project) {
         target = project.getObjects().property(JavaLanguageVersion.class);
-        runtime = project.getObjects().property(JavaLanguageVersion.class);
-        overrideLibraryAutoDetection = project.getObjects().property(Boolean.class);
         target.finalizeValueOnRead();
+
+        runtime = project.getObjects().property(JavaLanguageVersion.class);
         runtime.finalizeValueOnRead();
+
+        overrideLibraryAutoDetection = project.getObjects().property(Boolean.class);
         overrideLibraryAutoDetection.finalizeValueOnRead();
+
+        zuluVersions = project.getObjects().mapProperty(JavaLanguageVersion.class, String.class);
+        zuluVersions.putAll(project.provider(() -> parseOutVersions(project, ZULU_VERSION_PATTERN)));
+        zuluVersions.finalizeValueOnRead();
+
+        javaVersions = project.getObjects().mapProperty(JavaLanguageVersion.class, String.class);
+        javaVersions.putAll(project.provider(() -> parseOutVersions(project, JAVA_VERSION_PATTERN)));
+        javaVersions.finalizeValueOnRead();
     }
 
     /** Target {@link JavaLanguageVersion} for compilation. */
@@ -70,4 +89,28 @@ public final Property<Boolean> overrideLibraryAutoDetection() {
     public final void library() {
         overrideLibraryAutoDetection.set(true);
     }
+
+    public final MapProperty<JavaLanguageVersion, String> zuluVersions() {
+        return zuluVersions;
+    }
+
+    public final MapProperty<JavaLanguageVersion, String> javaVersions() {
+        return javaVersions;
+    }
+
+    private static Map<JavaLanguageVersion, String> parseOutVersions(Project project, Pattern propertyPattern) {
+        Map<JavaLanguageVersion, String> ret = new HashMap<>();
+
+        project.getProperties().forEach((key, value) -> {
+            Matcher matcher = propertyPattern.matcher(key);
+
+            if (!matcher.matches()) {
+                return;
+            }
+
+            ret.put(JavaLanguageVersion.of(Integer.parseInt(matcher.group(1))), (String) value);
+        });
+
+        return ret;
+    }
 }

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

@@ -17,6 +17,10 @@
 package com.palantir.baseline.plugins;
 
 import com.palantir.baseline.extensions.BaselineJavaVersionExtension;
+import com.palantir.baseline.plugins.javaversions.BaselineJavaVersionRootPlugin;
+import com.palantir.baseline.plugins.javaversions.JavaToolchains;
+import com.palantir.baseline.plugins.javaversions.JdkManager;
+import com.palantir.baseline.plugins.javaversions.PalantirJavaToolchain;
 import javax.inject.Inject;
 import org.gradle.api.Action;
 import org.gradle.api.DefaultTask;
@@ -37,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> {
@@ -48,6 +51,12 @@ public final class BaselineJavaVersion implements Plugin<Project> {
     public void apply(Project project) {
         BaselineJavaVersionExtension extension =
                 project.getExtensions().create(EXTENSION_NAME, BaselineJavaVersionExtension.class, project);
+
+        JdkManager jdkManager = project.getRootProject()
+                .getPlugins()
+                .apply(BaselineJavaVersionRootPlugin.class)
+                .jdkManager();
+
         project.getPluginManager().withPlugin("java", unused -> {
             JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
 
@@ -61,11 +70,13 @@ public void execute(JavaToolchainSpec javaToolchainSpec) {
                 }
             });
 
+            JavaToolchains javaToolchains = new JavaToolchains(project, extension, jdkManager);
+
             // Compilation tasks (using target version)
-            configureCompilationTasks(project, extension.target());
+            configureCompilationTasks(project, javaToolchains.forVersion(extension.target()));
 
             // Execution tasks (using the runtime version)
-            configureExecutionTasks(project, extension.runtime());
+            configureExecutionTasks(project, javaToolchains.forVersion(extension.runtime()));
 
             // Validation
             project.getTasks()
@@ -80,94 +91,55 @@ public void execute(CheckJavaVersionsTask task) {
         });
     }
 
-    private static void configureCompilationTasks(
-            Project project, Provider<JavaLanguageVersion> targetVersionProvider) {
-        JavaToolchainService javaToolchainService = project.getExtensions().getByType(JavaToolchainService.class);
-
+    private static void configureCompilationTasks(Project project, Provider<PalantirJavaToolchain> 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(PalantirJavaToolchain::javaCompiler));
             }
         });
 
         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(PalantirJavaToolchain::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(PalantirJavaToolchain::javaLauncher));
             }
         });
 
         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(PalantirJavaToolchain::javaLauncher));
             }
         });
 
         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(PalantirJavaToolchain::javaLauncher));
             }
         });
     }
 
-    private static void configureExecutionTasks(Project project, Provider<JavaLanguageVersion> runtimeVersionProvider) {
-        JavaToolchainService javaToolchainService = project.getExtensions().getByType(JavaToolchainService.class);
+    private static void configureExecutionTasks(Project project, Provider<PalantirJavaToolchain> 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(PalantirJavaToolchain::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(PalantirJavaToolchain::javaLauncher));
             }
         });
     }

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

@@ -0,0 +1,33 @@
+/*
+ * (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;
+
+final class AzulJavaToolchain implements PalantirJavaToolchain {
+    private final Provider<PalantirJavaInstallationMetadata> javaInstallationMetadata;
+
+    AzulJavaToolchain(Provider<PalantirJavaInstallationMetadata> javaInstallationMetadata) {
+        this.javaInstallationMetadata = javaInstallationMetadata;
+    }
+
+    @Override
+    public Provider<JavaCompiler> javaCompiler() {
+        return javaInstallationMetadata.map(PalantirJavaCompiler::new);
+    }
+
+    @Override
+    public Provider<JavadocTool> javadocTool() {
+        return javaInstallationMetadata.map(PalantirJavadocTool::new);
+    }
+
+    @Override
+    public Provider<JavaLauncher> javaLauncher() {
+        return javaInstallationMetadata.map(PalantirJavaLauncher::new);
+    }
+}

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

@@ -0,0 +1,59 @@
+/*
+ * (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 com.google.common.collect.Iterables;
+import java.nio.file.Path;
+import java.util.Optional;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+
+final class AzulJdkDownloader {
+    private static final String AZUL_JDK = "azul-jdk";
+
+    private final Project rootProject;
+
+    AzulJdkDownloader(Project rootProject) {
+        this.rootProject = rootProject;
+
+        if (rootProject != rootProject.getRootProject()) {
+            throw new IllegalArgumentException("Must pass in the root project");
+        }
+
+        String jdkBaseUrl = property("base-url").orElse("https://cdn.azul.com/zulu/bin/");
+
+        rootProject.getRepositories().ivy(ivy -> {
+            ivy.setName(AZUL_JDK);
+            ivy.setUrl(jdkBaseUrl);
+            ivy.patternLayout(patternLayout -> patternLayout.artifact("[module].[ext]"));
+            ivy.metadataSources(metadataSources -> metadataSources.artifact());
+            ivy.content(repositoryContentDescriptor -> {
+                repositoryContentDescriptor.includeGroup(AZUL_JDK);
+            });
+        });
+
+        rootProject
+                .getRepositories()
+                .matching(repo -> !repo.getName().equals(AZUL_JDK))
+                .configureEach(artifactRepository -> {
+                    artifactRepository.content(content -> content.excludeGroup(AZUL_JDK));
+                });
+    }
+
+    public Path downloadJdkFor(JdkSpec jdkSpec) {
+        Configuration configuration = rootProject
+                .getConfigurations()
+                .detachedConfiguration(rootProject
+                        .getDependencies()
+                        .create(String.format(
+                                "%s:zulu%s-ca-jdk%s-%s_%s:@zip",
+                                AZUL_JDK, jdkSpec.zuluVersion(), jdkSpec.javaVersion(), jdkSpec.os(), jdkSpec.arch())));
+        return Iterables.getOnlyElement(configuration.resolve()).toPath();
+    }
+
+    private Optional<String> property(String name) {
+        return Optional.ofNullable((String) rootProject.findProperty("com.palantir.baseline-java-versions." + name));
+    }
+}

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

@@ -0,0 +1,27 @@
+/*
+ * (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.Plugin;
+import org.gradle.api.Project;
+
+public final class BaselineJavaVersionRootPlugin implements Plugin<Project> {
+    private JdkManager jdkManager;
+
+    @Override
+    public void apply(Project rootProject) {
+        if (!rootProject.equals(rootProject.getRootProject())) {
+            throw new RuntimeException(
+                    BaselineJavaVersionRootPlugin.class + " can only be applied on the root project");
+        }
+
+        jdkManager =
+                new JdkManager(rootProject.getBuildDir().toPath().resolve("jdks"), new AzulJdkDownloader(rootProject));
+    }
+
+    public JdkManager jdkManager() {
+        return jdkManager;
+    }
+}