|
|
@@ -1,18 +1,27 @@
|
|
|
package org.elasticsearch.gradle.info;
|
|
|
|
|
|
import org.elasticsearch.gradle.OS;
|
|
|
+import org.elasticsearch.gradle.util.Util;
|
|
|
import org.gradle.api.GradleException;
|
|
|
import org.gradle.api.JavaVersion;
|
|
|
import org.gradle.api.Plugin;
|
|
|
import org.gradle.api.Project;
|
|
|
+import org.gradle.api.logging.Logger;
|
|
|
+import org.gradle.api.logging.Logging;
|
|
|
+import org.gradle.api.model.ObjectFactory;
|
|
|
+import org.gradle.api.provider.Provider;
|
|
|
+import org.gradle.api.provider.ProviderFactory;
|
|
|
import org.gradle.internal.jvm.Jvm;
|
|
|
+import org.gradle.jvm.toolchain.JavaInstallation;
|
|
|
+import org.gradle.jvm.toolchain.JavaInstallationRegistry;
|
|
|
+import org.gradle.util.GradleVersion;
|
|
|
|
|
|
+import javax.inject.Inject;
|
|
|
import java.io.BufferedReader;
|
|
|
import java.io.ByteArrayOutputStream;
|
|
|
import java.io.File;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.IOException;
|
|
|
-import java.io.InputStreamReader;
|
|
|
import java.io.UncheckedIOException;
|
|
|
import java.nio.charset.StandardCharsets;
|
|
|
import java.nio.file.Files;
|
|
|
@@ -33,102 +42,168 @@ import java.util.stream.Collectors;
|
|
|
import java.util.stream.Stream;
|
|
|
|
|
|
public class GlobalBuildInfoPlugin implements Plugin<Project> {
|
|
|
- private static final String GLOBAL_INFO_EXTENSION_NAME = "globalInfo";
|
|
|
+ private static final Logger LOGGER = Logging.getLogger(GlobalBuildInfoPlugin.class);
|
|
|
private static Integer _defaultParallel = null;
|
|
|
|
|
|
+ private final JavaInstallationRegistry javaInstallationRegistry;
|
|
|
+ private final ObjectFactory objects;
|
|
|
+ private final ProviderFactory providers;
|
|
|
+
|
|
|
+ @Inject
|
|
|
+ public GlobalBuildInfoPlugin(JavaInstallationRegistry javaInstallationRegistry, ObjectFactory objects, ProviderFactory providers) {
|
|
|
+ this.javaInstallationRegistry = javaInstallationRegistry;
|
|
|
+ this.objects = objects;
|
|
|
+ this.providers = providers;
|
|
|
+ }
|
|
|
+
|
|
|
@Override
|
|
|
public void apply(Project project) {
|
|
|
if (project != project.getRootProject()) {
|
|
|
throw new IllegalStateException(this.getClass().getName() + " can only be applied to the root project.");
|
|
|
}
|
|
|
|
|
|
- GlobalInfoExtension extension = project.getExtensions().create(GLOBAL_INFO_EXTENSION_NAME, GlobalInfoExtension.class);
|
|
|
-
|
|
|
- JavaVersion minimumCompilerVersion = JavaVersion.toVersion(getResourceContents("/minimumCompilerVersion"));
|
|
|
- JavaVersion minimumRuntimeVersion = JavaVersion.toVersion(getResourceContents("/minimumRuntimeVersion"));
|
|
|
+ JavaVersion minimumCompilerVersion = JavaVersion.toVersion(Util.getResourceContents("/minimumCompilerVersion"));
|
|
|
+ JavaVersion minimumRuntimeVersion = JavaVersion.toVersion(Util.getResourceContents("/minimumRuntimeVersion"));
|
|
|
|
|
|
File compilerJavaHome = findCompilerJavaHome();
|
|
|
File runtimeJavaHome = findRuntimeJavaHome(compilerJavaHome);
|
|
|
|
|
|
- String testSeedProperty = System.getProperty("tests.seed");
|
|
|
- final String testSeed;
|
|
|
- if (testSeedProperty == null) {
|
|
|
- long seed = new Random(System.currentTimeMillis()).nextLong();
|
|
|
- testSeed = Long.toUnsignedString(seed, 16).toUpperCase(Locale.ROOT);
|
|
|
- } else {
|
|
|
- testSeed = testSeedProperty;
|
|
|
- }
|
|
|
-
|
|
|
- final String buildSnapshotSystemProperty = System.getProperty("build.snapshot", "true");
|
|
|
- final boolean isSnapshotBuild;
|
|
|
- switch (buildSnapshotSystemProperty) {
|
|
|
- case "true":
|
|
|
- isSnapshotBuild = true;
|
|
|
- break;
|
|
|
- case "false":
|
|
|
- isSnapshotBuild = false;
|
|
|
- break;
|
|
|
- default:
|
|
|
- throw new IllegalArgumentException(
|
|
|
- "build.snapshot was set to [" + buildSnapshotSystemProperty + "] but can only be unset or [true|false]"
|
|
|
- );
|
|
|
- }
|
|
|
- final List<JavaHome> javaVersions = new ArrayList<>();
|
|
|
- for (int version = 8; version <= Integer.parseInt(minimumCompilerVersion.getMajorVersion()); version++) {
|
|
|
- if (System.getenv(getJavaHomeEnvVarName(Integer.toString(version))) != null) {
|
|
|
- javaVersions.add(JavaHome.of(version, new File(findJavaHome(Integer.toString(version)))));
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- GenerateGlobalBuildInfoTask generateTask = project.getTasks()
|
|
|
- .create("generateGlobalBuildInfo", GenerateGlobalBuildInfoTask.class, task -> {
|
|
|
- task.setJavaVersions(javaVersions);
|
|
|
- task.setMinimumCompilerVersion(minimumCompilerVersion);
|
|
|
- task.setMinimumRuntimeVersion(minimumRuntimeVersion);
|
|
|
- task.setCompilerJavaHome(compilerJavaHome);
|
|
|
- task.setRuntimeJavaHome(runtimeJavaHome);
|
|
|
- task.getOutputFile().set(new File(project.getBuildDir(), "global-build-info"));
|
|
|
- task.getCompilerVersionFile().set(new File(project.getBuildDir(), "java-compiler-version"));
|
|
|
- task.getRuntimeVersionFile().set(new File(project.getBuildDir(), "java-runtime-version"));
|
|
|
- });
|
|
|
-
|
|
|
- PrintGlobalBuildInfoTask printTask = project.getTasks().create("printGlobalBuildInfo", PrintGlobalBuildInfoTask.class, task -> {
|
|
|
- task.getBuildInfoFile().set(generateTask.getOutputFile());
|
|
|
- task.getCompilerVersionFile().set(generateTask.getCompilerVersionFile());
|
|
|
- task.getRuntimeVersionFile().set(generateTask.getRuntimeVersionFile());
|
|
|
- task.setGlobalInfoListeners(extension.listeners);
|
|
|
- });
|
|
|
-
|
|
|
// Initialize global build parameters
|
|
|
BuildParams.init(params -> {
|
|
|
params.reset();
|
|
|
params.setCompilerJavaHome(compilerJavaHome);
|
|
|
params.setRuntimeJavaHome(runtimeJavaHome);
|
|
|
+ params.setCompilerJavaVersion(determineJavaVersion("compiler java.home", compilerJavaHome, minimumCompilerVersion));
|
|
|
+ params.setRuntimeJavaVersion(determineJavaVersion("runtime java.home", runtimeJavaHome, minimumRuntimeVersion));
|
|
|
params.setIsRutimeJavaHomeSet(compilerJavaHome.equals(runtimeJavaHome) == false);
|
|
|
- params.setJavaVersions(javaVersions);
|
|
|
+ params.setJavaVersions(getAvailableJavaVersions(minimumCompilerVersion));
|
|
|
params.setMinimumCompilerVersion(minimumCompilerVersion);
|
|
|
params.setMinimumRuntimeVersion(minimumRuntimeVersion);
|
|
|
params.setGradleJavaVersion(Jvm.current().getJavaVersion());
|
|
|
params.setGitRevision(gitRevision(project.getRootProject().getRootDir()));
|
|
|
params.setBuildDate(ZonedDateTime.now(ZoneOffset.UTC));
|
|
|
- params.setTestSeed(testSeed);
|
|
|
+ params.setTestSeed(getTestSeed());
|
|
|
params.setIsCi(System.getenv("JENKINS_URL") != null);
|
|
|
params.setIsInternal(GlobalBuildInfoPlugin.class.getResource("/buildSrc.marker") != null);
|
|
|
params.setDefaultParallel(findDefaultParallel(project));
|
|
|
- params.setInFipsJvm(isInFipsJvm());
|
|
|
- params.setIsSnapshotBuild(isSnapshotBuild);
|
|
|
+ params.setInFipsJvm(Util.getBooleanProperty("tests.fips.enabled", false));
|
|
|
+ params.setIsSnapshotBuild(Util.getBooleanProperty("build.snapshot", true));
|
|
|
});
|
|
|
|
|
|
- project.allprojects(
|
|
|
- p -> {
|
|
|
- // Make sure than any task execution generates and prints build info
|
|
|
- p.getTasks().configureEach(task -> {
|
|
|
- if (task != generateTask && task != printTask) {
|
|
|
- task.dependsOn(printTask);
|
|
|
+ // Print global build info header just before task execution
|
|
|
+ project.getGradle().getTaskGraph().whenReady(graph -> logGlobalBuildInfo());
|
|
|
+ }
|
|
|
+
|
|
|
+ private void logGlobalBuildInfo() {
|
|
|
+ final String osName = System.getProperty("os.name");
|
|
|
+ final String osVersion = System.getProperty("os.version");
|
|
|
+ final String osArch = System.getProperty("os.arch");
|
|
|
+ final Jvm gradleJvm = Jvm.current();
|
|
|
+ final String gradleJvmDetails = getJavaInstallation(gradleJvm.getJavaHome()).getImplementationName();
|
|
|
+
|
|
|
+ LOGGER.quiet("=======================================");
|
|
|
+ LOGGER.quiet("Elasticsearch Build Hamster says Hello!");
|
|
|
+ LOGGER.quiet(" Gradle Version : " + GradleVersion.current().getVersion());
|
|
|
+ LOGGER.quiet(" OS Info : " + osName + " " + osVersion + " (" + osArch + ")");
|
|
|
+ if (Jvm.current().getJavaVersion().equals(BuildParams.getCompilerJavaVersion()) == false || BuildParams.getIsRuntimeJavaHomeSet()) {
|
|
|
+ String compilerJvmDetails = getJavaInstallation(BuildParams.getCompilerJavaHome()).getImplementationName();
|
|
|
+ String runtimeJvmDetails = getJavaInstallation(BuildParams.getRuntimeJavaHome()).getImplementationName();
|
|
|
+
|
|
|
+ LOGGER.quiet(" Compiler JDK Version : " + BuildParams.getCompilerJavaVersion() + " (" + compilerJvmDetails + ")");
|
|
|
+ LOGGER.quiet(" Compiler java.home : " + BuildParams.getCompilerJavaHome());
|
|
|
+ LOGGER.quiet(" Runtime JDK Version : " + BuildParams.getRuntimeJavaVersion() + " (" + runtimeJvmDetails + ")");
|
|
|
+ LOGGER.quiet(" Runtime java.home : " + BuildParams.getRuntimeJavaHome());
|
|
|
+ LOGGER.quiet(" Gradle JDK Version : " + gradleJvm.getJavaVersion() + " (" + gradleJvmDetails + ")");
|
|
|
+ LOGGER.quiet(" Gradle java.home : " + gradleJvm.getJavaHome());
|
|
|
+ } else {
|
|
|
+ LOGGER.quiet(" JDK Version : " + gradleJvm.getJavaVersion() + " (" + gradleJvmDetails + ")");
|
|
|
+ LOGGER.quiet(" JAVA_HOME : " + gradleJvm.getJavaHome());
|
|
|
+ }
|
|
|
+ LOGGER.quiet(" Random Testing Seed : " + BuildParams.getTestSeed());
|
|
|
+ LOGGER.quiet(" In FIPS 140 mode : " + BuildParams.isInFipsJvm());
|
|
|
+ LOGGER.quiet("=======================================");
|
|
|
+ }
|
|
|
+
|
|
|
+ private JavaVersion determineJavaVersion(String description, File javaHome, JavaVersion requiredVersion) {
|
|
|
+ JavaInstallation installation = getJavaInstallation(javaHome);
|
|
|
+ JavaVersion actualVersion = installation.getJavaVersion();
|
|
|
+ if (actualVersion.isCompatibleWith(requiredVersion) == false) {
|
|
|
+ throwInvalidJavaHomeException(
|
|
|
+ description,
|
|
|
+ javaHome,
|
|
|
+ Integer.parseInt(requiredVersion.getMajorVersion()),
|
|
|
+ Integer.parseInt(actualVersion.getMajorVersion())
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ return actualVersion;
|
|
|
+ }
|
|
|
+
|
|
|
+ private JavaInstallation getJavaInstallation(File javaHome) {
|
|
|
+ JavaInstallation installation;
|
|
|
+ if (isCurrentJavaHome(javaHome)) {
|
|
|
+ installation = javaInstallationRegistry.getInstallationForCurrentVirtualMachine().get();
|
|
|
+ } else {
|
|
|
+ installation = javaInstallationRegistry.installationForDirectory(objects.directoryProperty().fileValue(javaHome)).get();
|
|
|
+ }
|
|
|
+
|
|
|
+ return installation;
|
|
|
+ }
|
|
|
+
|
|
|
+ private List<JavaHome> getAvailableJavaVersions(JavaVersion minimumCompilerVersion) {
|
|
|
+ final List<JavaHome> javaVersions = new ArrayList<>();
|
|
|
+ for (int v = 8; v <= Integer.parseInt(minimumCompilerVersion.getMajorVersion()); v++) {
|
|
|
+ int version = v;
|
|
|
+ String javaHomeEnvVarName = getJavaHomeEnvVarName(Integer.toString(version));
|
|
|
+ if (System.getenv(javaHomeEnvVarName) != null) {
|
|
|
+ File javaHomeDirectory = new File(findJavaHome(Integer.toString(version)));
|
|
|
+ Provider<JavaInstallation> javaInstallationProvider = javaInstallationRegistry.installationForDirectory(
|
|
|
+ objects.directoryProperty().fileValue(javaHomeDirectory)
|
|
|
+ );
|
|
|
+ JavaHome javaHome = JavaHome.of(version, providers.provider(() -> {
|
|
|
+ int actualVersion = Integer.parseInt(javaInstallationProvider.get().getJavaVersion().getMajorVersion());
|
|
|
+ if (actualVersion != version) {
|
|
|
+ throwInvalidJavaHomeException("env variable " + javaHomeEnvVarName, javaHomeDirectory, version, actualVersion);
|
|
|
}
|
|
|
- });
|
|
|
+ return javaHomeDirectory;
|
|
|
+ }));
|
|
|
+ javaVersions.add(javaHome);
|
|
|
}
|
|
|
+ }
|
|
|
+ return javaVersions;
|
|
|
+ }
|
|
|
+
|
|
|
+ private static boolean isCurrentJavaHome(File javaHome) {
|
|
|
+ try {
|
|
|
+ return Files.isSameFile(javaHome.toPath(), Jvm.current().getJavaHome().toPath());
|
|
|
+ } catch (IOException e) {
|
|
|
+ throw new UncheckedIOException(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private static String getTestSeed() {
|
|
|
+ String testSeedProperty = System.getProperty("tests.seed");
|
|
|
+ final String testSeed;
|
|
|
+ if (testSeedProperty == null) {
|
|
|
+ long seed = new Random(System.currentTimeMillis()).nextLong();
|
|
|
+ testSeed = Long.toUnsignedString(seed, 16).toUpperCase(Locale.ROOT);
|
|
|
+ } else {
|
|
|
+ testSeed = testSeedProperty;
|
|
|
+ }
|
|
|
+ return testSeed;
|
|
|
+ }
|
|
|
+
|
|
|
+ private static void throwInvalidJavaHomeException(String description, File javaHome, int expectedVersion, int actualVersion) {
|
|
|
+ String message = String.format(
|
|
|
+ Locale.ROOT,
|
|
|
+ "The %s must be set to a JDK installation directory for Java %d but is [%s] corresponding to [%s]",
|
|
|
+ description,
|
|
|
+ expectedVersion,
|
|
|
+ javaHome,
|
|
|
+ actualVersion
|
|
|
);
|
|
|
+
|
|
|
+ throw new GradleException(message);
|
|
|
}
|
|
|
|
|
|
private static File findCompilerJavaHome() {
|
|
|
@@ -174,28 +249,6 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
|
|
|
return "JAVA" + version + "_HOME";
|
|
|
}
|
|
|
|
|
|
- private static boolean isInFipsJvm() {
|
|
|
- return Boolean.parseBoolean(System.getProperty("tests.fips.enabled"));
|
|
|
- }
|
|
|
-
|
|
|
- private static String getResourceContents(String resourcePath) {
|
|
|
- try (
|
|
|
- BufferedReader reader = new BufferedReader(new InputStreamReader(GlobalBuildInfoPlugin.class.getResourceAsStream(resourcePath)))
|
|
|
- ) {
|
|
|
- StringBuilder b = new StringBuilder();
|
|
|
- for (String line = reader.readLine(); line != null; line = reader.readLine()) {
|
|
|
- if (b.length() != 0) {
|
|
|
- b.append('\n');
|
|
|
- }
|
|
|
- b.append(line);
|
|
|
- }
|
|
|
-
|
|
|
- return b.toString();
|
|
|
- } catch (IOException e) {
|
|
|
- throw new UncheckedIOException("Error trying to read classpath resource: " + resourcePath, e);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
private static int findDefaultParallel(Project project) {
|
|
|
// Since it costs IO to compute this, and is done at configuration time we want to cache this if possible
|
|
|
// It's safe to store this in a static variable since it's just a primitive so leaking memory isn't an issue
|
Mark Vieira