github-mirrors/elasticsearch
1
0
Fork 0
mirror of https://github.com/elastic/elasticsearch.git synced 2025-04-19 04:45:07 -04:00
Code Issues Projects Releases Packages Wiki Activity

[Gradle] Remove static use of BuildParams (#115122)

Browse source 
Static fields dont do well in Gradle with configuration cache enabled.

- Use buildParams extension in build scripts
- Keep BuildParams.ci for now for easy serverless migration
-  Tweak testing doc
This commit is contained in:
Rene Groeschke 2024-11-15 17:58:57 +01:00 • committed by GitHub
parent 4d338496f8
commit 13c8aaeffa
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
185 changed files with 965 additions and 615 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
TESTING.asciidoc
View file

@ -625,7 +625,7 @@ For specific YAML rest tests one can use
For disabling entire types of tests for subprojects, one can use for example:
------------------------------------------------
if (BuildParams.inFipsJvm){
if (buildParams.inFipsJvm) {
// This test cluster is using a BASIC license and FIPS 140 mode is not supported in BASIC
tasks.named("javaRestTest").configure{enabled = false }
}

3
benchmarks/build.gradle
View file

@ -1,4 +1,3 @@
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.internal.test.TestUtil
/*
@ -78,7 +77,7 @@ tasks.register("copyPainless", Copy) {
}
tasks.named("run").configure {
executable = "${BuildParams.runtimeJavaHome}/bin/java"
executable = "${buildParams.runtimeJavaHome.get()}/bin/java"
args << "-Dplugins.dir=${buildDir}/plugins" << "-Dtests.index=${buildDir}/index"
dependsOn "copyExpression", "copyPainless", configurations.nativeLib
systemProperty 'es.nativelibs.path', TestUtil.getTestLibraryPath(file("../libs/native/libraries/build/platform/").toString())

8
build-conventions/src/main/java/org/elasticsearch/gradle/internal/conventions/GUtils.java
View file

@ -16,4 +16,12 @@ public abstract class GUtils {
public static String capitalize(String s) {
return s.substring(0, 1).toUpperCase(Locale.ROOT) + s.substring(1);
}
public static <T> T elvis(T given, T fallback) {
if (given == null) {
return fallback;
} else {
return given;
}
}
}

11
build-tools-internal/build.gradle
View file

@ -386,10 +386,13 @@ tasks.named("jar") {
spotless {
java {
// IDEs can sometimes run annotation processors that leave files in
// here, causing Spotless to complain. Even though this path ought not
// to exist, exclude it anyway in order to avoid spurious failures.
toggleOffOn()
// workaround for https://github.com/diffplug/spotless/issues/2317
//toggleOffOn()
target project.fileTree("src/main/java") {
include '**/*.java'
exclude '**/DockerBase.java'
}
}
}

6
build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/InternalDistributionBwcSetupPluginFuncTest.groovy
View file

@ -9,16 +9,10 @@
package org.elasticsearch.gradle.internal
import org.elasticsearch.gradle.Architecture
import org.elasticsearch.gradle.fixtures.AbstractGitAwareGradleFuncTest
import org.gradle.testkit.runner.TaskOutcome
import spock.lang.IgnoreIf
import spock.lang.Unroll
/*
* Test is ignored on ARM since this test case tests the ability to build certain older BWC branches that we don't support on ARM
*/
@IgnoreIf({ Architecture.current() == Architecture.AARCH64 })
class InternalDistributionBwcSetupPluginFuncTest extends AbstractGitAwareGradleFuncTest {
def setup() {

3
build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/PublishPluginFuncTest.groovy
View file

@ -440,8 +440,7 @@ class PublishPluginFuncTest extends AbstractGradleFuncTest {
// scm info only added for internal builds
internalBuild()
buildFile << """
BuildParams.init { it.setGitOrigin("https://some-repo.com/repo.git") }
buildParams.getGitOriginProperty().set("https://some-repo.com/repo.git")
apply plugin:'elasticsearch.java'
apply plugin:'elasticsearch.publish'

2
build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/snyk/SnykDependencyMonitoringGradlePluginFuncTest.groovy
View file

@ -161,7 +161,7 @@ class SnykDependencyMonitoringGradlePluginFuncTest extends AbstractGradleInterna
},
"target": {
"remoteUrl": "http://acme.org",
"branch": "unknown"
"branch": "$version"
},
"targetReference": "$version",
"projectAttributes": {

9
build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/test/rest/LegacyYamlRestTestPluginFuncTest.groovy
View file

@ -10,6 +10,7 @@
package org.elasticsearch.gradle.internal.test.rest
import spock.lang.IgnoreIf
import spock.lang.IgnoreRest
import org.elasticsearch.gradle.VersionProperties
import org.elasticsearch.gradle.fixtures.AbstractRestResourcesFuncTest
@ -20,16 +21,16 @@ import org.gradle.testkit.runner.TaskOutcome
class LegacyYamlRestTestPluginFuncTest extends AbstractRestResourcesFuncTest {
def setup() {
configurationCacheCompatible = true
buildApiRestrictionsDisabled = true
}
def "yamlRestTest does nothing when there are no tests"() {
given:
internalBuild()
buildFile << """
plugins {
id 'elasticsearch.legacy-yaml-rest-test'
}
apply plugin: 'elasticsearch.legacy-yaml-rest-test'
"""
when:
@ -136,7 +137,7 @@ class LegacyYamlRestTestPluginFuncTest extends AbstractRestResourcesFuncTest {
"""
when:
def result = gradleRunner("yamlRestTest", "--console", 'plain', '--stacktrace').buildAndFail()
def result = gradleRunner("yamlRestTest", "--console", 'plain').buildAndFail()
then:
result.task(":distribution:archives:integ-test-zip:buildExpanded").outcome == TaskOutcome.SUCCESS

10
build-tools-internal/src/main/groovy/elasticsearch.build-scan.gradle
View file

@ -12,7 +12,6 @@ import java.time.LocalDateTime;
import org.elasticsearch.gradle.Architecture
import org.elasticsearch.gradle.OS
import org.elasticsearch.gradle.internal.info.BuildParams
import java.lang.management.ManagementFactory
import java.time.LocalDateTime
@ -34,12 +33,15 @@ develocity {
publishing.onlyIf { false }
}
def fips = buildParams.inFipsJvm
def gitRevision = buildParams.gitRevision
background {
tag OS.current().name()
tag Architecture.current().name()
// Tag if this build is run in FIPS mode
if (BuildParams.inFipsJvm) {
if (fips) {
tag 'FIPS'
}
@ -92,8 +94,8 @@ develocity {
link 'Source', "${prBaseUrl}/tree/${System.getenv('BUILDKITE_COMMIT')}"
link 'Pull Request', "https://github.com/${repository}/pull/${prId}"
} else {
value 'Git Commit ID', BuildParams.gitRevision
link 'Source', "https://github.com/${repository}/tree/${BuildParams.gitRevision}"
value 'Git Commit ID', gitRevision
link 'Source', "https://github.com/${repository}/tree/${gitRevision}"
}
buildFinished { result ->

3
build-tools-internal/src/main/groovy/elasticsearch.bwc-test.gradle
View file

@ -9,7 +9,6 @@
import org.elasticsearch.gradle.Version
import org.elasticsearch.gradle.internal.ElasticsearchTestBasePlugin
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.internal.test.rest.InternalJavaRestTestPlugin
import org.elasticsearch.gradle.testclusters.StandaloneRestIntegTestTask
@ -19,7 +18,7 @@ ext.bwcTaskName = { Version version ->
def bwcTestSnapshots = tasks.register("bwcTestSnapshots") {
if (project.bwc_tests_enabled) {
dependsOn tasks.matching { task -> BuildParams.bwcVersions.unreleased.any { version -> bwcTaskName(version) == task.name } }
dependsOn tasks.matching { task -> buildParams.bwcVersions.unreleased.any { version -> bwcTaskName(version) == task.name } }
}
}

7
build-tools-internal/src/main/groovy/elasticsearch.fips.gradle
View file

@ -15,11 +15,12 @@ import org.elasticsearch.gradle.testclusters.StandaloneRestIntegTestTask
import org.elasticsearch.gradle.testclusters.TestClustersAware
import org.elasticsearch.gradle.testclusters.TestDistribution
// Common config when running with a FIPS-140 runtime JVM
if (BuildParams.inFipsJvm) {
//apply plugin: org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin
// Common config when running with a FIPS-140 runtime JVM
if (buildParams.inFipsJvm) {
allprojects {
String javaSecurityFilename = BuildParams.runtimeJavaDetails.toLowerCase().contains('oracle') ? 'fips_java_oracle.security' : 'fips_java.security'
String javaSecurityFilename = buildParams.runtimeJavaDetails.toLowerCase().contains('oracle') ? 'fips_java_oracle.security' : 'fips_java.security'
File fipsResourcesDir = new File(project.buildDir, 'fips-resources')
File fipsSecurity = new File(fipsResourcesDir, javaSecurityFilename)
File fipsPolicy = new File(fipsResourcesDir, 'fips_java.policy')

2
build-tools-internal/src/main/groovy/elasticsearch.ide.gradle
View file

@ -171,7 +171,7 @@ if (providers.systemProperty('idea.active').getOrNull() == 'true') {
idea {
project {
vcs = 'Git'
jdkName = BuildParams.minimumCompilerVersion.majorVersion
jdkName = buildParams.minimumCompilerVersion.majorVersion
settings {
delegateActions {

7
build-tools-internal/src/main/groovy/elasticsearch.runtime-jdk-provision.gradle
View file

@ -10,7 +10,6 @@
import org.elasticsearch.gradle.Architecture
import org.elasticsearch.gradle.OS
import org.elasticsearch.gradle.VersionProperties
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.internal.precommit.ThirdPartyAuditPrecommitPlugin
import org.elasticsearch.gradle.internal.precommit.ThirdPartyAuditTask
import org.elasticsearch.gradle.internal.test.rest.RestTestBasePlugin
@ -27,8 +26,8 @@ configure(allprojects) {
JvmVendorSpec.matching(VersionProperties.bundledJdkVendor)
}
project.tasks.withType(Test).configureEach { Test test ->
if (BuildParams.getIsRuntimeJavaHomeSet()) {
test.executable = "${BuildParams.runtimeJavaHome}/bin/java" +
if (buildParams.getIsRuntimeJavaHomeSet()) {
test.executable = "${buildParams.runtimeJavaHome.get()}/bin/java" +
(OS.current() == OS.WINDOWS ? '.exe' : '')
} else {
test.javaLauncher = javaToolchains.launcherFor {
@ -41,7 +40,7 @@ configure(allprojects) {
}
project.plugins.withId("elasticsearch.testclusters") { testClustersPlugin ->
project.plugins.withId("elasticsearch.internal-testclusters") { internalPlugin ->
if (BuildParams.getIsRuntimeJavaHomeSet() == false) {
if (buildParams.getIsRuntimeJavaHomeSet() == false) {
// If no runtime java home is set, use the bundled JDK for test clusters
testClustersPlugin.setRuntimeJava(launcher.map { it.metadata.installationPath.asFile })
}

4
build-tools-internal/src/main/groovy/elasticsearch.stable-api.gradle
View file

@ -17,11 +17,11 @@ dependencies {
newJar project(":libs:${project.name}")
}
BuildParams.bwcVersions.withIndexCompatible({ it.onOrAfter(Version.fromString(ext.stableApiSince))
buildParams.bwcVersions.withIndexCompatible({ it.onOrAfter(Version.fromString(ext.stableApiSince))
&& it != VersionProperties.elasticsearchVersion
}) { bwcVersion, baseName ->
BwcVersions.UnreleasedVersionInfo unreleasedVersion = BuildParams.bwcVersions.unreleasedInfo(bwcVersion)
BwcVersions.UnreleasedVersionInfo unreleasedVersion = buildParams.bwcVersions.unreleasedInfo(bwcVersion)
configurations {
"oldJar${baseName}" {

5
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/BaseInternalPluginBuildPlugin.java
View file

@ -12,7 +12,7 @@ package org.elasticsearch.gradle.internal;
import groovy.lang.Closure;
import org.elasticsearch.gradle.internal.conventions.util.Util;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.precommit.JarHellPrecommitPlugin;
import org.elasticsearch.gradle.internal.test.HistoricalFeaturesMetadataPlugin;
import org.elasticsearch.gradle.plugin.PluginBuildPlugin;
@ -39,6 +39,7 @@ public class BaseInternalPluginBuildPlugin implements Plugin<Project> {
project.getPluginManager().apply(JarHellPrecommitPlugin.class);
project.getPluginManager().apply(ElasticsearchJavaPlugin.class);
project.getPluginManager().apply(HistoricalFeaturesMetadataPlugin.class);
boolean isCi = project.getRootProject().getExtensions().getByType(BuildParameterExtension.class).isCi();
// Clear default dependencies added by public PluginBuildPlugin as we add our
// own project dependencies for internal builds
// TODO remove once we removed default dependencies from PluginBuildPlugin
@ -54,7 +55,7 @@ public class BaseInternalPluginBuildPlugin implements Plugin<Project> {
.set("addQaCheckDependencies", new Closure<Project>(BaseInternalPluginBuildPlugin.this, BaseInternalPluginBuildPlugin.this) {
public void doCall(Project proj) {
// This is only a convenience for local developers so make this a noop when running in CI
if (BuildParams.isCi() == false) {
if (isCi == false) {
proj.afterEvaluate(project1 -> {
// let check depend on check tasks of qa sub-projects
final var checkTaskProvider = project1.getTasks().named("check");

14
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/BwcSetupExtension.java
View file

@ -13,7 +13,6 @@ import org.apache.commons.io.FileUtils;
import org.elasticsearch.gradle.LoggedExec;
import org.elasticsearch.gradle.OS;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.gradle.api.Action;
import org.gradle.api.GradleException;
import org.gradle.api.Project;
@ -47,6 +46,7 @@ public class BwcSetupExtension {
private final ProviderFactory providerFactory;
private final JavaToolchainService toolChainService;
private final Provider<BwcVersions.UnreleasedVersionInfo> unreleasedVersionInfo;
private final Boolean isCi;
private Provider<File> checkoutDir;
@ -56,7 +56,8 @@ public class BwcSetupExtension {
ProviderFactory providerFactory,
JavaToolchainService toolChainService,
Provider<BwcVersions.UnreleasedVersionInfo> unreleasedVersionInfo,
Provider<File> checkoutDir
Provider<File> checkoutDir,
Boolean isCi
) {
this.project = project;
this.objectFactory = objectFactory;
@ -64,6 +65,7 @@ public class BwcSetupExtension {
this.toolChainService = toolChainService;
this.unreleasedVersionInfo = unreleasedVersionInfo;
this.checkoutDir = checkoutDir;
this.isCi = isCi;
}
TaskProvider<LoggedExec> bwcTask(String name, Action<LoggedExec> configuration) {
@ -80,7 +82,8 @@ public class BwcSetupExtension {
toolChainService,
name,
configuration,
useUniqueUserHome
useUniqueUserHome,
isCi
);
}
@ -93,7 +96,8 @@ public class BwcSetupExtension {
JavaToolchainService toolChainService,
String name,
Action<LoggedExec> configAction,
boolean useUniqueUserHome
boolean useUniqueUserHome,
boolean isCi
) {
return project.getTasks().register(name, LoggedExec.class, loggedExec -> {
loggedExec.dependsOn("checkoutBwcBranch");
@ -104,7 +108,7 @@ public class BwcSetupExtension {
spec.getParameters().getCheckoutDir().set(checkoutDir);
}).flatMap(s -> getJavaHome(objectFactory, toolChainService, Integer.parseInt(s))));
if (BuildParams.isCi() && OS.current() != OS.WINDOWS) {
if (isCi && OS.current() != OS.WINDOWS) {
// TODO: Disabled for now until we can figure out why files are getting corrupted
// loggedExec.getEnvironment().put("GRADLE_RO_DEP_CACHE", System.getProperty("user.home") + "/gradle_ro_cache");
}

6
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/BwcVersions.java
View file

@ -11,6 +11,7 @@ package org.elasticsearch.gradle.internal;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.VersionProperties;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
@ -60,7 +61,8 @@ import static java.util.Collections.unmodifiableList;
* We are then able to map the unreleased version to branches in git and Gradle projects that are capable of checking
* out and building them, so we can include these in the testing plan as well.
*/
public class BwcVersions {
public class BwcVersions implements Serializable {
private static final Pattern LINE_PATTERN = Pattern.compile(
"\\W+public static final Version V_(\\d+)_(\\d+)_(\\d+)(_alpha\\d+|_beta\\d+|_rc\\d+)?.*\\);"
@ -68,7 +70,7 @@ public class BwcVersions {
private static final String GLIBC_VERSION_ENV_VAR = "GLIBC_VERSION";
private final Version currentVersion;
private final List<Version> versions;
private final transient List<Version> versions;
private final Map<Version, UnreleasedVersionInfo> unreleased;
public BwcVersions(List<String> versionLines) {

17
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/ElasticsearchJavaBasePlugin.java
View file

@ -11,7 +11,7 @@ package org.elasticsearch.gradle.internal;
import org.elasticsearch.gradle.VersionProperties;
import org.elasticsearch.gradle.internal.conventions.precommit.PrecommitTaskPlugin;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.internal.test.MutedTestPlugin;
import org.elasticsearch.gradle.internal.test.TestUtil;
@ -49,6 +49,7 @@ import javax.inject.Inject;
public class ElasticsearchJavaBasePlugin implements Plugin<Project> {
private final JavaToolchainService javaToolchains;
private BuildParameterExtension buildParams;
@Inject
ElasticsearchJavaBasePlugin(JavaToolchainService javaToolchains) {
@ -57,8 +58,10 @@ public class ElasticsearchJavaBasePlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
// make sure the global build info plugin is applied to the root project
project.getRootProject().getPluginManager().apply(GlobalBuildInfoPlugin.class);
buildParams = project.getRootProject().getExtensions().getByType(BuildParameterExtension.class);
project.getPluginManager().apply(JavaBasePlugin.class);
// common repositories setup
project.getPluginManager().apply(RepositoriesSetupPlugin.class);
@ -129,14 +132,14 @@ public class ElasticsearchJavaBasePlugin implements Plugin<Project> {
public void configureCompile(Project project) {
project.getExtensions().getExtraProperties().set("compactProfile", "full");
JavaPluginExtension java = project.getExtensions().getByType(JavaPluginExtension.class);
if (BuildParams.getJavaToolChainSpec().isPresent()) {
java.toolchain(BuildParams.getJavaToolChainSpec().get());
if (buildParams.getJavaToolChainSpec().isPresent()) {
java.toolchain(buildParams.getJavaToolChainSpec().get());
}
java.setSourceCompatibility(BuildParams.getMinimumRuntimeVersion());
java.setTargetCompatibility(BuildParams.getMinimumRuntimeVersion());
java.setSourceCompatibility(buildParams.getMinimumRuntimeVersion());
java.setTargetCompatibility(buildParams.getMinimumRuntimeVersion());
project.getTasks().withType(JavaCompile.class).configureEach(compileTask -> {
compileTask.getJavaCompiler().set(javaToolchains.compilerFor(spec -> {
spec.getLanguageVersion().set(JavaLanguageVersion.of(BuildParams.getMinimumRuntimeVersion().getMajorVersion()));
spec.getLanguageVersion().set(JavaLanguageVersion.of(buildParams.getMinimumRuntimeVersion().getMajorVersion()));
}));
CompileOptions compileOptions = compileTask.getOptions();
@ -159,7 +162,7 @@ public class ElasticsearchJavaBasePlugin implements Plugin<Project> {
compileTask.getConventionMapping().map("sourceCompatibility", () -> java.getSourceCompatibility().toString());
compileTask.getConventionMapping().map("targetCompatibility", () -> java.getTargetCompatibility().toString());
compileOptions.getRelease().set(releaseVersionProviderFromCompileTask(project, compileTask));
compileOptions.setIncremental(BuildParams.isCi() == false);
compileOptions.setIncremental(buildParams.isCi() == false);
});
// also apply release flag to groovy, which is used in build-tools
project.getTasks().withType(GroovyCompile.class).configureEach(compileTask -> {

30
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/ElasticsearchJavaPlugin.java
View file

@ -15,8 +15,10 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar;
import org.elasticsearch.gradle.VersionProperties;
import org.elasticsearch.gradle.internal.conventions.util.Util;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.Action;
import org.gradle.api.JavaVersion;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
@ -24,6 +26,7 @@ import org.gradle.api.artifacts.Configuration;
import org.gradle.api.plugins.BasePlugin;
import org.gradle.api.plugins.JavaLibraryPlugin;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.bundling.Jar;
import org.gradle.api.tasks.javadoc.Javadoc;
@ -34,6 +37,7 @@ import java.io.File;
import java.util.Map;
import static org.elasticsearch.gradle.internal.conventions.util.Util.toStringable;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* A wrapper around Gradle's Java plugin that applies our
@ -42,13 +46,15 @@ import static org.elasticsearch.gradle.internal.conventions.util.Util.toStringab
public class ElasticsearchJavaPlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
Property<BuildParameterExtension> buildParams = loadBuildParams(project);
project.getPluginManager().apply(ElasticsearchJavaBasePlugin.class);
project.getPluginManager().apply(JavaLibraryPlugin.class);
project.getPluginManager().apply(ElasticsearchJavaModulePathPlugin.class);
// configureConfigurations(project);
configureJars(project);
configureJarManifest(project);
configureJars(project, buildParams.get());
configureJarManifest(project, buildParams.get());
configureJavadoc(project);
testCompileOnlyDeps(project);
}
@ -63,7 +69,9 @@ public class ElasticsearchJavaPlugin implements Plugin<Project> {
/**
* Adds additional manifest info to jars
*/
static void configureJars(Project project) {
static void configureJars(Project project, BuildParameterExtension buildParams) {
String buildDate = buildParams.getBuildDate().toString();
JavaVersion gradleJavaVersion = buildParams.getGradleJavaVersion();
project.getTasks().withType(Jar.class).configureEach(jarTask -> {
// we put all our distributable files under distributions
jarTask.getDestinationDirectory().set(new File(project.getBuildDir(), "distributions"));
@ -75,10 +83,7 @@ public class ElasticsearchJavaPlugin implements Plugin<Project> {
public void execute(Task task) {
// this doFirst is added before the info plugin, therefore it will run
// after the doFirst added by the info plugin, and we can override attributes
jarTask.getManifest()
.attributes(
Map.of("Build-Date", BuildParams.getBuildDate(), "Build-Java-Version", BuildParams.getGradleJavaVersion())
);
jarTask.getManifest().attributes(Map.of("Build-Date", buildDate, "Build-Java-Version", gradleJavaVersion));
}
});
});
@ -102,10 +107,13 @@ public class ElasticsearchJavaPlugin implements Plugin<Project> {
});
}
private static void configureJarManifest(Project project) {
private static void configureJarManifest(Project project, BuildParameterExtension buildParams) {
String gitOrigin = buildParams.getGitOrigin();
String gitRevision = buildParams.getGitRevision();
project.getPlugins().withType(InfoBrokerPlugin.class).whenPluginAdded(manifestPlugin -> {
manifestPlugin.add("Module-Origin", toStringable(BuildParams::getGitOrigin));
manifestPlugin.add("Change", toStringable(BuildParams::getGitRevision));
manifestPlugin.add("Module-Origin", toStringable(() -> gitOrigin));
manifestPlugin.add("Change", toStringable(() -> gitRevision));
manifestPlugin.add("X-Compile-Elasticsearch-Version", toStringable(VersionProperties::getElasticsearch));
manifestPlugin.add("X-Compile-Lucene-Version", toStringable(VersionProperties::getLucene));
manifestPlugin.add(

13
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/ElasticsearchTestBasePlugin.java
View file

@ -13,7 +13,7 @@ import com.github.jengelman.gradle.plugins.shadow.ShadowBasePlugin;
import org.elasticsearch.gradle.OS;
import org.elasticsearch.gradle.internal.conventions.util.Util;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.internal.test.ErrorReportingTestListener;
import org.elasticsearch.gradle.internal.test.SimpleCommandLineArgumentProvider;
@ -26,6 +26,7 @@ import org.gradle.api.Task;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.file.FileCollection;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;
@ -37,6 +38,7 @@ import java.util.Map;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
import static org.elasticsearch.gradle.util.FileUtils.mkdirs;
import static org.elasticsearch.gradle.util.GradleUtils.maybeConfigure;
@ -52,6 +54,9 @@ public abstract class ElasticsearchTestBasePlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
Property<BuildParameterExtension> buildParams = loadBuildParams(project);
project.getPluginManager().apply(GradleTestPolicySetupPlugin.class);
// for fips mode check
project.getRootProject().getPluginManager().apply(GlobalBuildInfoPlugin.class);
@ -100,7 +105,7 @@ public abstract class ElasticsearchTestBasePlugin implements Plugin<Project> {
test.getExtensions().add("nonInputProperties", nonInputProperties);
test.setWorkingDir(project.file(project.getBuildDir() + "/testrun/" + test.getName().replace("#", "_")));
test.setMaxParallelForks(Integer.parseInt(System.getProperty("tests.jvms", BuildParams.getDefaultParallel().toString())));
test.setMaxParallelForks(Integer.parseInt(System.getProperty("tests.jvms", buildParams.get().getDefaultParallel().toString())));
test.exclude("**/*$*.class");
@ -146,9 +151,9 @@ public abstract class ElasticsearchTestBasePlugin implements Plugin<Project> {
// ignore changing test seed when build is passed -Dignore.tests.seed for cacheability experimentation
if (System.getProperty("ignore.tests.seed") != null) {
nonInputProperties.systemProperty("tests.seed", BuildParams.getTestSeed());
nonInputProperties.systemProperty("tests.seed", buildParams.get().getTestSeed());
} else {
test.systemProperty("tests.seed", BuildParams.getTestSeed());
test.systemProperty("tests.seed", buildParams.get().getTestSeed());
}
// don't track these as inputs since they contain absolute paths and break cache relocatability

24
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/InternalDistributionBwcSetupPlugin.java
View file

@ -10,7 +10,7 @@
package org.elasticsearch.gradle.internal;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.Action;
import org.gradle.api.InvalidUserDataException;
@ -39,6 +39,7 @@ import javax.inject.Inject;
import static java.util.Arrays.asList;
import static java.util.Arrays.stream;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* We want to be able to do BWC tests for unreleased versions without relying on and waiting for snapshots.
@ -64,23 +65,29 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
project.getRootProject().getPluginManager().apply(GlobalBuildInfoPlugin.class);
project.getPlugins().apply(JvmToolchainsPlugin.class);
toolChainService = project.getExtensions().getByType(JavaToolchainService.class);
BuildParams.getBwcVersions().forPreviousUnreleased((BwcVersions.UnreleasedVersionInfo unreleasedVersion) -> {
BuildParameterExtension buildParams = loadBuildParams(project).get();
Boolean isCi = buildParams.isCi();
buildParams.getBwcVersions().forPreviousUnreleased((BwcVersions.UnreleasedVersionInfo unreleasedVersion) -> {
configureBwcProject(
project.project(unreleasedVersion.gradleProjectPath()),
buildParams,
unreleasedVersion,
providerFactory,
objectFactory,
toolChainService
toolChainService,
isCi
);
});
}
private static void configureBwcProject(
Project project,
BuildParameterExtension buildParams,
BwcVersions.UnreleasedVersionInfo versionInfo,
ProviderFactory providerFactory,
ObjectFactory objectFactory,
JavaToolchainService toolChainService
JavaToolchainService toolChainService,
Boolean isCi
) {
ProjectLayout layout = project.getLayout();
Provider<BwcVersions.UnreleasedVersionInfo> versionInfoProvider = providerFactory.provider(() -> versionInfo);
@ -96,7 +103,8 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
providerFactory,
toolChainService,
versionInfoProvider,
checkoutDir
checkoutDir,
isCi
);
BwcGitExtension gitExtension = project.getPlugins().apply(InternalBwcGitPlugin.class).getGitExtension();
Provider<Version> bwcVersion = versionInfoProvider.map(info -> info.version());
@ -122,6 +130,7 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
for (DistributionProject distributionProject : distributionProjects) {
createBuildBwcTask(
bwcSetupExtension,
buildParams,
project,
bwcVersion,
distributionProject.name,
@ -144,6 +153,7 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
createBuildBwcTask(
bwcSetupExtension,
buildParams,
project,
bwcVersion,
"jdbc",
@ -177,6 +187,7 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
createBuildBwcTask(
bwcSetupExtension,
buildParams,
project,
bwcVersion,
stableApiProject.getName(),
@ -296,6 +307,7 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
static void createBuildBwcTask(
BwcSetupExtension bwcSetupExtension,
BuildParameterExtension buildParams,
Project project,
Provider<Version> bwcVersion,
String projectName,
@ -316,7 +328,7 @@ public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
} else {
c.getOutputs().files(expectedOutputFile);
}
c.getOutputs().doNotCacheIf("BWC distribution caching is disabled for local builds", task -> BuildParams.isCi() == false);
c.getOutputs().doNotCacheIf("BWC distribution caching is disabled for local builds", task -> buildParams.isCi() == false);
c.getArgs().add("-p");
c.getArgs().add(projectPath);
c.getArgs().add(assembleTaskName);

15
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/InternalDistributionDownloadPlugin.java
View file

@ -20,7 +20,7 @@ import org.elasticsearch.gradle.distribution.ElasticsearchDistributionTypes;
import org.elasticsearch.gradle.internal.distribution.InternalElasticsearchDistributionTypes;
import org.elasticsearch.gradle.internal.docker.DockerSupportPlugin;
import org.elasticsearch.gradle.internal.docker.DockerSupportService;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.util.GradleUtils;
import org.gradle.api.GradleException;
@ -35,6 +35,8 @@ import java.util.List;
import java.util.Map;
import java.util.function.Function;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* An internal elasticsearch build plugin that registers additional
* distribution resolution strategies to the 'elasticsearch.download-distribution' plugin
@ -47,6 +49,8 @@ public class InternalDistributionDownloadPlugin implements Plugin<Project> {
// this is needed for isInternal
project.getRootProject().getPluginManager().apply(GlobalBuildInfoPlugin.class);
project.getRootProject().getPluginManager().apply(DockerSupportPlugin.class);
BuildParameterExtension buildParams = loadBuildParams(project).get();
DistributionDownloadPlugin distributionDownloadPlugin = project.getPlugins().apply(DistributionDownloadPlugin.class);
Provider<DockerSupportService> dockerSupport = GradleUtils.getBuildService(
project.getGradle().getSharedServices(),
@ -55,7 +59,10 @@ public class InternalDistributionDownloadPlugin implements Plugin<Project> {
distributionDownloadPlugin.setDockerAvailability(
dockerSupport.map(dockerSupportService -> dockerSupportService.getDockerAvailability().isAvailable())
);
registerInternalDistributionResolutions(DistributionDownloadPlugin.getRegistrationsContainer(project));
registerInternalDistributionResolutions(
DistributionDownloadPlugin.getRegistrationsContainer(project),
buildParams.getBwcVersionsProperty()
);
}
/**
@ -66,7 +73,7 @@ public class InternalDistributionDownloadPlugin implements Plugin<Project> {
* <p>
* BWC versions are resolved as project to projects under `:distribution:bwc`.
*/
private void registerInternalDistributionResolutions(List<DistributionResolution> resolutions) {
private void registerInternalDistributionResolutions(List<DistributionResolution> resolutions, Provider<BwcVersions> bwcVersions) {
resolutions.add(new DistributionResolution("local-build", (project, distribution) -> {
if (isCurrentVersion(distribution)) {
// non-external project, so depend on local build
@ -78,7 +85,7 @@ public class InternalDistributionDownloadPlugin implements Plugin<Project> {
}));
resolutions.add(new DistributionResolution("bwc", (project, distribution) -> {
BwcVersions.UnreleasedVersionInfo unreleasedInfo = BuildParams.getBwcVersions()
BwcVersions.UnreleasedVersionInfo unreleasedInfo = bwcVersions.get()
.unreleasedInfo(Version.fromString(distribution.getVersion()));
if (unreleasedInfo != null) {
if (distribution.getBundledJdk() == false) {

21
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/InternalTestClustersPlugin.java
View file

@ -10,34 +10,29 @@
package org.elasticsearch.gradle.internal;
import org.elasticsearch.gradle.VersionProperties;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.testclusters.ElasticsearchCluster;
import org.elasticsearch.gradle.testclusters.TestClustersPlugin;
import org.gradle.api.NamedDomainObjectContainer;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.provider.ProviderFactory;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class InternalTestClustersPlugin implements Plugin<Project> {
private ProviderFactory providerFactory;
@Inject
public InternalTestClustersPlugin(ProviderFactory providerFactory) {
this.providerFactory = providerFactory;
}
@Override
public void apply(Project project) {
project.getPlugins().apply(InternalDistributionDownloadPlugin.class);
project.getRootProject().getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
BuildParameterExtension buildParams = loadBuildParams(project).get();
project.getRootProject().getPluginManager().apply(InternalReaperPlugin.class);
TestClustersPlugin testClustersPlugin = project.getPlugins().apply(TestClustersPlugin.class);
testClustersPlugin.setRuntimeJava(providerFactory.provider(() -> BuildParams.getRuntimeJavaHome()));
testClustersPlugin.setRuntimeJava(buildParams.getRuntimeJavaHome());
testClustersPlugin.setIsReleasedVersion(
version -> (version.equals(VersionProperties.getElasticsearchVersion()) && BuildParams.isSnapshotBuild() == false)
|| BuildParams.getBwcVersions().unreleasedInfo(version) == null
version -> (version.equals(VersionProperties.getElasticsearchVersion()) && buildParams.isSnapshotBuild() == false)
|| buildParams.getBwcVersions().unreleasedInfo(version) == null
);
if (shouldConfigureTestClustersWithOneProcessor()) {

20
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/MrjarPlugin.java
View file

@ -9,7 +9,8 @@
package org.elasticsearch.gradle.internal;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.internal.precommit.CheckForbiddenApisTask;
import org.elasticsearch.gradle.util.GradleUtils;
import org.gradle.api.JavaVersion;
@ -47,6 +48,7 @@ import java.util.stream.Stream;
import javax.inject.Inject;
import static de.thetaphi.forbiddenapis.gradle.ForbiddenApisPlugin.FORBIDDEN_APIS_TASK_NAME;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
import static org.objectweb.asm.Opcodes.V_PREVIEW;
public class MrjarPlugin implements Plugin<Project> {
@ -64,6 +66,8 @@ public class MrjarPlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getPluginManager().apply(ElasticsearchJavaBasePlugin.class);
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
var buildParams = loadBuildParams(project).get();
var javaExtension = project.getExtensions().getByType(JavaPluginExtension.class);
var isIdeaSync = System.getProperty("idea.sync.active", "false").equals("true");
var ideaSourceSetsEnabled = project.hasProperty(MRJAR_IDEA_ENABLED) && project.property(MRJAR_IDEA_ENABLED).equals("true");
@ -89,7 +93,7 @@ public class MrjarPlugin implements Plugin<Project> {
String testSourceSetName = SourceSet.TEST_SOURCE_SET_NAME + javaVersion;
SourceSet testSourceSet = addSourceSet(project, javaExtension, testSourceSetName, testSourceSets, javaVersion);
testSourceSets.add(testSourceSetName);
createTestTask(project, testSourceSet, javaVersion, mainSourceSets);
createTestTask(project, buildParams, testSourceSet, javaVersion, mainSourceSets);
}
}
@ -163,7 +167,13 @@ public class MrjarPlugin implements Plugin<Project> {
jarTask.configure(task -> task.into("META-INF/versions/" + javaVersion, copySpec -> copySpec.from(sourceSet.getOutput())));
}
private void createTestTask(Project project, SourceSet sourceSet, int javaVersion, List<String> mainSourceSets) {
private void createTestTask(
Project project,
BuildParameterExtension buildParams,
SourceSet sourceSet,
int javaVersion,
List<String> mainSourceSets
) {
var jarTask = project.getTasks().withType(Jar.class).named(JavaPlugin.JAR_TASK_NAME);
var testTaskProvider = project.getTasks().register(JavaPlugin.TEST_TASK_NAME + javaVersion, Test.class);
testTaskProvider.configure(testTask -> {
@ -180,9 +190,9 @@ public class MrjarPlugin implements Plugin<Project> {
// only set the jdk if runtime java isn't set because setting the toolchain is incompatible with
// runtime java setting the executable directly
if (BuildParams.getIsRuntimeJavaHomeSet()) {
if (buildParams.getIsRuntimeJavaHomeSet()) {
testTask.onlyIf("runtime java must support java " + javaVersion, t -> {
JavaVersion runtimeJavaVersion = BuildParams.getRuntimeJavaVersion();
JavaVersion runtimeJavaVersion = buildParams.getRuntimeJavaVersion().get();
return runtimeJavaVersion.isCompatibleWith(JavaVersion.toVersion(javaVersion));
});
} else {

6
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/docker/DockerSupportPlugin.java
View file

@ -8,6 +8,7 @@
*/
package org.elasticsearch.gradle.internal.docker;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
@ -17,6 +18,8 @@ import java.io.File;
import java.util.List;
import java.util.stream.Collectors;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* Plugin providing {@link DockerSupportService} for detecting Docker installations and determining requirements for Docker-based
* Elasticsearch build tasks.
@ -30,11 +33,14 @@ public class DockerSupportPlugin implements Plugin<Project> {
if (project != project.getRootProject()) {
throw new IllegalStateException(this.getClass().getName() + " can only be applied to the root project.");
}
project.getPlugins().apply(GlobalBuildInfoPlugin.class);
var buildParams = loadBuildParams(project).get();
Provider<DockerSupportService> dockerSupportServiceProvider = project.getGradle()
.getSharedServices()
.registerIfAbsent(DOCKER_SUPPORT_SERVICE_NAME, DockerSupportService.class, spec -> spec.parameters(params -> {
params.setExclusionsFile(new File(project.getRootDir(), DOCKER_ON_LINUX_EXCLUSIONS_FILE));
params.getIsCI().set(buildParams.isCi());
}));
// Ensure that if we are trying to run any DockerBuildTask tasks, we assert an available Docker installation exists

11
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/docker/DockerSupportService.java
View file

@ -13,10 +13,10 @@ import com.avast.gradle.dockercompose.ServiceInfo;
import org.elasticsearch.gradle.Architecture;
import org.elasticsearch.gradle.OS;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.gradle.api.GradleException;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.services.BuildService;
import org.gradle.api.services.BuildServiceParameters;
@ -59,7 +59,6 @@ public abstract class DockerSupportService implements BuildService<DockerSupport
private final ProviderFactory providerFactory;
private DockerAvailability dockerAvailability;
private Map<String, ServiceInfo> serviceInfos;
private Map<String, Map<Integer, Integer>> tcpPorts;
private Map<String, Map<Integer, Integer>> udpPorts;
@ -228,7 +227,7 @@ public abstract class DockerSupportService implements BuildService<DockerSupport
// We don't attempt to check the current flavor and version of Linux unless we're
// running in CI, because we don't want to stop people running the Docker tests in
// their own environments if they really want to.
if (BuildParams.isCi() == false) {
if (getParameters().getIsCI().get().booleanValue() == false) {
return false;
}
@ -356,10 +355,6 @@ public abstract class DockerSupportService implements BuildService<DockerSupport
return udpPorts;
}
public void setServiceInfos(Map<String, ServiceInfo> serviceInfos) {
this.serviceInfos = serviceInfos;
}
/**
* An immutable class that represents the results of a Docker search from {@link #getDockerAvailability()}}.
*/
@ -402,5 +397,7 @@ public abstract class DockerSupportService implements BuildService<DockerSupport
File getExclusionsFile();
void setExclusionsFile(File exclusionsFile);
Property<Boolean> getIsCI();
}
}

187
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/info/BuildParameterExtension.java Normal file
View file

@ -0,0 +1,187 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.gradle.internal.info;
import org.elasticsearch.gradle.internal.BwcVersions;
import org.gradle.api.Action;
import org.gradle.api.JavaVersion;
import org.gradle.api.Task;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import java.io.File;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Random;
import java.util.concurrent.atomic.AtomicReference;
public abstract class BuildParameterExtension {
private final Provider<Boolean> inFipsJvm;
private final Provider<File> runtimeJavaHome;
private final Boolean isRuntimeJavaHomeSet;
private final List<JavaHome> javaVersions;
private final JavaVersion minimumCompilerVersion;
private final JavaVersion minimumRuntimeVersion;
private final JavaVersion gradleJavaVersion;
private final Provider<JavaVersion> runtimeJavaVersion;
private final Provider<? extends Action<JavaToolchainSpec>> javaToolChainSpec;
private final Provider<String> runtimeJavaDetails;
private final String gitRevision;
private transient AtomicReference<ZonedDateTime> buildDate = new AtomicReference<>();
private final String testSeed;
private final Boolean isCi;
private final Integer defaultParallel;
private final Boolean isSnapshotBuild;
public BuildParameterExtension(
ProviderFactory providers,
Provider<File> runtimeJavaHome,
Provider<? extends Action<JavaToolchainSpec>> javaToolChainSpec,
Provider<JavaVersion> runtimeJavaVersion,
boolean isRuntimeJavaHomeSet,
Provider<String> runtimeJavaDetails,
List<JavaHome> javaVersions,
JavaVersion minimumCompilerVersion,
JavaVersion minimumRuntimeVersion,
JavaVersion gradleJavaVersion,
String gitRevision,
String gitOrigin,
ZonedDateTime buildDate,
String testSeed,
boolean isCi,
int defaultParallel,
final boolean isSnapshotBuild,
Provider<BwcVersions> bwcVersions
) {
this.inFipsJvm = providers.systemProperty("tests.fips.enabled").map(BuildParameterExtension::parseBoolean);
this.runtimeJavaHome = runtimeJavaHome;
this.javaToolChainSpec = javaToolChainSpec;
this.runtimeJavaVersion = runtimeJavaVersion;
this.isRuntimeJavaHomeSet = isRuntimeJavaHomeSet;
this.runtimeJavaDetails = runtimeJavaDetails;
this.javaVersions = javaVersions;
this.minimumCompilerVersion = minimumCompilerVersion;
this.minimumRuntimeVersion = minimumRuntimeVersion;
this.gradleJavaVersion = gradleJavaVersion;
this.gitRevision = gitRevision;
this.testSeed = testSeed;
this.isCi = isCi;
this.defaultParallel = defaultParallel;
this.isSnapshotBuild = isSnapshotBuild;
this.getBwcVersionsProperty().set(bwcVersions);
this.getGitOriginProperty().set(gitOrigin);
}
private static boolean parseBoolean(String s) {
if (s == null) {
return false;
}
return Boolean.parseBoolean(s);
}
public boolean getInFipsJvm() {
return inFipsJvm.getOrElse(false);
}
public Provider<File> getRuntimeJavaHome() {
return runtimeJavaHome;
}
public void withFipsEnabledOnly(Task task) {
task.onlyIf("FIPS mode disabled", task1 -> getInFipsJvm() == false);
}
public Boolean getIsRuntimeJavaHomeSet() {
return isRuntimeJavaHomeSet;
}
public List<JavaHome> getJavaVersions() {
return javaVersions;
}
public JavaVersion getMinimumCompilerVersion() {
return minimumCompilerVersion;
}
public JavaVersion getMinimumRuntimeVersion() {
return minimumRuntimeVersion;
}
public JavaVersion getGradleJavaVersion() {
return gradleJavaVersion;
}
public Provider<JavaVersion> getRuntimeJavaVersion() {
return runtimeJavaVersion;
}
public Provider<? extends Action<JavaToolchainSpec>> getJavaToolChainSpec() {
return javaToolChainSpec;
}
public Provider<String> getRuntimeJavaDetails() {
return runtimeJavaDetails;
}
public String getGitRevision() {
return gitRevision;
}
public String getGitOrigin() {
return getGitOriginProperty().get();
}
public ZonedDateTime getBuildDate() {
ZonedDateTime value = buildDate.get();
if (value == null) {
value = ZonedDateTime.now(ZoneOffset.UTC);
if (buildDate.compareAndSet(null, value) == false) {
// If another thread initialized it first, return the initialized value
value = buildDate.get();
}
}
return value;
}
public String getTestSeed() {
return testSeed;
}
public Boolean isCi() {
return isCi;
}
public Integer getDefaultParallel() {
return defaultParallel;
}
public Boolean isSnapshotBuild() {
return isSnapshotBuild;
}
public BwcVersions getBwcVersions() {
return getBwcVersionsProperty().get();
}
public abstract Property<BwcVersions> getBwcVersionsProperty();
public abstract Property<String> getGitOriginProperty();
public Random getRandom() {
return new Random(Long.parseUnsignedLong(testSeed.split(":")[0], 16));
}
public Boolean isGraalVmRuntime() {
return runtimeJavaDetails.get().toLowerCase().contains("graalvm");
}
}

20
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/info/BuildParameterService.java Normal file
View file

@ -0,0 +1,20 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.gradle.internal.info;
import org.gradle.api.provider.Property;
import org.gradle.api.services.BuildService;
import org.gradle.api.services.BuildServiceParameters;
public abstract class BuildParameterService implements BuildService<BuildParameterService.Params>, AutoCloseable {
public interface Params extends BuildServiceParameters {
Property<BuildParameterExtension> getBuildParams();
}
}

186
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/info/BuildParams.java
View file

@ -8,43 +8,13 @@
*/
package org.elasticsearch.gradle.internal.info;
import org.elasticsearch.gradle.internal.BwcVersions;
import org.gradle.api.Action;
import org.gradle.api.JavaVersion;
import org.gradle.api.Task;
import org.gradle.api.provider.Provider;
import org.gradle.jvm.toolchain.JavaToolchainSpec;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Modifier;
import java.time.ZonedDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import static java.util.Objects.requireNonNull;
@Deprecated
public class BuildParams {
private static Provider<File> runtimeJavaHome;
private static Boolean isRuntimeJavaHomeSet;
private static List<JavaHome> javaVersions;
private static JavaVersion minimumCompilerVersion;
private static JavaVersion minimumRuntimeVersion;
private static JavaVersion gradleJavaVersion;
private static Provider<JavaVersion> runtimeJavaVersion;
private static Provider<? extends Action<JavaToolchainSpec>> javaToolChainSpec;
private static Provider<String> runtimeJavaDetails;
private static Boolean inFipsJvm;
private static String gitRevision;
private static String gitOrigin;
private static ZonedDateTime buildDate;
private static String testSeed;
private static Boolean isCi;
private static Integer defaultParallel;
private static Boolean isSnapshotBuild;
private static Provider<BwcVersions> bwcVersions;
/**
* Initialize global build parameters. This method accepts and a initialization function which in turn accepts a
@ -58,90 +28,10 @@ public class BuildParams {
initializer.accept(MutableBuildParams.INSTANCE);
}
public static File getRuntimeJavaHome() {
return value(runtimeJavaHome).get();
}
public static Boolean getIsRuntimeJavaHomeSet() {
return value(isRuntimeJavaHomeSet);
}
public static List<JavaHome> getJavaVersions() {
return value(javaVersions);
}
public static JavaVersion getMinimumCompilerVersion() {
return value(minimumCompilerVersion);
}
public static JavaVersion getMinimumRuntimeVersion() {
return value(minimumRuntimeVersion);
}
public static JavaVersion getGradleJavaVersion() {
return value(gradleJavaVersion);
}
public static JavaVersion getRuntimeJavaVersion() {
return value(runtimeJavaVersion.get());
}
public static String getRuntimeJavaDetails() {
return value(runtimeJavaDetails.get());
}
public static Boolean isInFipsJvm() {
return value(inFipsJvm);
}
public static void withFipsEnabledOnly(Task task) {
task.onlyIf("FIPS mode disabled", task1 -> isInFipsJvm() == false);
}
public static String getGitRevision() {
return value(gitRevision);
}
public static String getGitOrigin() {
return value(gitOrigin);
}
public static ZonedDateTime getBuildDate() {
return value(buildDate);
}
public static BwcVersions getBwcVersions() {
return value(bwcVersions).get();
}
public static String getTestSeed() {
return value(testSeed);
}
public static Random getRandom() {
return new Random(Long.parseUnsignedLong(testSeed.split(":")[0], 16));
}
public static Boolean isCi() {
return value(isCi);
}
public static Boolean isGraalVmRuntime() {
return value(runtimeJavaDetails.get().toLowerCase().contains("graalvm"));
}
public static Integer getDefaultParallel() {
return value(defaultParallel);
}
public static boolean isSnapshotBuild() {
return value(BuildParams.isSnapshotBuild);
}
public static Provider<? extends Action<JavaToolchainSpec>> getJavaToolChainSpec() {
return javaToolChainSpec;
}
private static <T> T value(T object) {
if (object == null) {
String callingMethod = Thread.currentThread().getStackTrace()[2].getMethodName();
@ -183,82 +73,8 @@ public class BuildParams {
});
}
public void setRuntimeJavaHome(Provider<File> runtimeJavaHome) {
BuildParams.runtimeJavaHome = runtimeJavaHome.map(javaHome -> {
try {
return javaHome.getCanonicalFile();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
}
public void setIsRuntimeJavaHomeSet(boolean isRuntimeJavaHomeSet) {
BuildParams.isRuntimeJavaHomeSet = isRuntimeJavaHomeSet;
}
public void setJavaVersions(List<JavaHome> javaVersions) {
BuildParams.javaVersions = requireNonNull(javaVersions);
}
public void setMinimumCompilerVersion(JavaVersion minimumCompilerVersion) {
BuildParams.minimumCompilerVersion = requireNonNull(minimumCompilerVersion);
}
public void setMinimumRuntimeVersion(JavaVersion minimumRuntimeVersion) {
BuildParams.minimumRuntimeVersion = requireNonNull(minimumRuntimeVersion);
}
public void setGradleJavaVersion(JavaVersion gradleJavaVersion) {
BuildParams.gradleJavaVersion = requireNonNull(gradleJavaVersion);
}
public void setRuntimeJavaVersion(Provider<JavaVersion> runtimeJavaVersion) {
BuildParams.runtimeJavaVersion = requireNonNull(runtimeJavaVersion);
}
public void setRuntimeJavaDetails(Provider<String> runtimeJavaDetails) {
BuildParams.runtimeJavaDetails = runtimeJavaDetails;
}
public void setInFipsJvm(boolean inFipsJvm) {
BuildParams.inFipsJvm = inFipsJvm;
}
public void setGitRevision(String gitRevision) {
BuildParams.gitRevision = requireNonNull(gitRevision);
}
public void setGitOrigin(String gitOrigin) {
BuildParams.gitOrigin = requireNonNull(gitOrigin);
}
public void setBuildDate(ZonedDateTime buildDate) {
BuildParams.buildDate = requireNonNull(buildDate);
}
public void setTestSeed(String testSeed) {
BuildParams.testSeed = requireNonNull(testSeed);
}
public void setIsCi(boolean isCi) {
BuildParams.isCi = isCi;
}
public void setDefaultParallel(int defaultParallel) {
BuildParams.defaultParallel = defaultParallel;
}
public void setIsSnapshotBuild(final boolean isSnapshotBuild) {
BuildParams.isSnapshotBuild = isSnapshotBuild;
}
public void setBwcVersions(Provider<BwcVersions> bwcVersions) {
BuildParams.bwcVersions = requireNonNull(bwcVersions);
}
public void setJavaToolChainSpec(Provider<? extends Action<JavaToolchainSpec>> javaToolChain) {
BuildParams.javaToolChainSpec = javaToolChain;
}
}
}

99
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/info/GlobalBuildInfoPlugin.java
View file

@ -58,6 +58,8 @@ import java.util.stream.Stream;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.conventions.GUtils.elvis;
public class GlobalBuildInfoPlugin implements Plugin<Project> {
private static final Logger LOGGER = Logging.getLogger(GlobalBuildInfoPlugin.class);
private static final String DEFAULT_VERSION_JAVA_FILE_PATH = "server/src/main/java/org/elasticsearch/Version.java";
@ -67,6 +69,7 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
private final JvmMetadataDetector metadataDetector;
private final ProviderFactory providers;
private JavaToolchainService toolChainService;
private Project project;
@Inject
public GlobalBuildInfoPlugin(
@ -87,6 +90,7 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
if (project != project.getRootProject()) {
throw new IllegalStateException(this.getClass().getName() + " can only be applied to the root project.");
}
this.project = project;
project.getPlugins().apply(JvmToolchainsPlugin.class);
toolChainService = project.getExtensions().getByType(JavaToolchainService.class);
GradleVersion minimumGradleVersion = GradleVersion.version(getResourceContents("/minimumGradleVersion"));
@ -98,55 +102,61 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
JavaVersion minimumRuntimeVersion = JavaVersion.toVersion(getResourceContents("/minimumRuntimeVersion"));
Provider<File> explicitRuntimeJavaHome = findRuntimeJavaHome();
boolean isExplicitRuntimeJavaHomeSet = explicitRuntimeJavaHome.isPresent();
Provider<File> actualRuntimeJavaHome = isExplicitRuntimeJavaHomeSet
boolean isRuntimeJavaHomeExplicitlySet = explicitRuntimeJavaHome.isPresent();
Provider<File> actualRuntimeJavaHome = isRuntimeJavaHomeExplicitlySet
? explicitRuntimeJavaHome
: resolveJavaHomeFromToolChainService(VersionProperties.getBundledJdkMajorVersion());
GitInfo gitInfo = GitInfo.gitInfo(project.getRootDir());
BuildParams.init(params -> {
params.reset();
params.setRuntimeJavaHome(actualRuntimeJavaHome);
params.setJavaToolChainSpec(resolveToolchainSpecFromEnv());
Provider<JvmInstallationMetadata> runtimeJdkMetaData = actualRuntimeJavaHome.map(
runtimeJavaHome -> metadataDetector.getMetadata(getJavaInstallation(runtimeJavaHome))
);
params.setRuntimeJavaVersion(
Provider<JvmInstallationMetadata> runtimeJdkMetaData = actualRuntimeJavaHome.map(
runtimeJavaHome -> metadataDetector.getMetadata(getJavaInstallation(runtimeJavaHome))
);
AtomicReference<BwcVersions> cache = new AtomicReference<>();
Provider<BwcVersions> bwcVersionsProvider = providers.provider(
() -> cache.updateAndGet(val -> val == null ? resolveBwcVersions() : val)
);
BuildParameterExtension buildParams = project.getExtensions()
.create(
"buildParams",
BuildParameterExtension.class,
actualRuntimeJavaHome,
resolveToolchainSpecFromEnv(),
actualRuntimeJavaHome.map(
javaHome -> determineJavaVersion(
"runtime java.home",
javaHome,
isExplicitRuntimeJavaHomeSet
isRuntimeJavaHomeExplicitlySet
? minimumRuntimeVersion
: JavaVersion.toVersion(VersionProperties.getBundledJdkMajorVersion())
)
)
),
isRuntimeJavaHomeExplicitlySet,
runtimeJdkMetaData.map(m -> formatJavaVendorDetails(m)),
getAvailableJavaVersions(),
minimumCompilerVersion,
minimumRuntimeVersion,
Jvm.current().getJavaVersion(),
gitInfo.getRevision(),
gitInfo.getOrigin(),
ZonedDateTime.now(ZoneOffset.UTC),
getTestSeed(),
System.getenv("JENKINS_URL") != null || System.getenv("BUILDKITE_BUILD_URL") != null || System.getProperty("isCI") != null,
ParallelDetector.findDefaultParallel(project),
Util.getBooleanProperty("build.snapshot", true),
bwcVersionsProvider
);
params.setIsRuntimeJavaHomeSet(isExplicitRuntimeJavaHomeSet);
params.setRuntimeJavaDetails(runtimeJdkMetaData.map(m -> formatJavaVendorDetails(m)));
params.setJavaVersions(getAvailableJavaVersions());
params.setMinimumCompilerVersion(minimumCompilerVersion);
params.setMinimumRuntimeVersion(minimumRuntimeVersion);
params.setGradleJavaVersion(Jvm.current().getJavaVersion());
params.setGitRevision(gitInfo.getRevision());
params.setGitOrigin(gitInfo.getOrigin());
params.setBuildDate(ZonedDateTime.now(ZoneOffset.UTC));
params.setTestSeed(getTestSeed());
project.getGradle().getSharedServices().registerIfAbsent("buildParams", BuildParameterService.class, spec -> {
// Provide some parameters
spec.getParameters().getBuildParams().set(buildParams);
});
BuildParams.init(params -> {
params.reset();
params.setIsCi(
System.getenv("JENKINS_URL") != null || System.getenv("BUILDKITE_BUILD_URL") != null || System.getProperty("isCI") != null
);
params.setDefaultParallel(ParallelDetector.findDefaultParallel(project));
params.setInFipsJvm(Util.getBooleanProperty("tests.fips.enabled", false));
params.setIsSnapshotBuild(Util.getBooleanProperty("build.snapshot", true));
AtomicReference<BwcVersions> cache = new AtomicReference<>();
params.setBwcVersions(
providers.provider(
() -> cache.updateAndGet(
val -> val == null ? resolveBwcVersions(Util.locateElasticsearchWorkspace(project.getGradle())) : val
)
)
);
});
// Enforce the minimum compiler version
@ -155,7 +165,7 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
// Print global build info header just before task execution
// Only do this if we are the root build of a composite
if (GradleUtils.isIncludedBuild(project) == false) {
project.getGradle().getTaskGraph().whenReady(graph -> logGlobalBuildInfo());
project.getGradle().getTaskGraph().whenReady(graph -> logGlobalBuildInfo(buildParams));
}
}
@ -180,9 +190,12 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
/* Introspect all versions of ES that may be tested against for backwards
* compatibility. It is *super* important that this logic is the same as the
* logic in VersionUtils.java. */
private static BwcVersions resolveBwcVersions(File root) {
File versionsFile = new File(root, DEFAULT_VERSION_JAVA_FILE_PATH);
try (var is = new FileInputStream(versionsFile)) {
private BwcVersions resolveBwcVersions() {
String versionsFilePath = elvis(
System.getProperty("BWC_VERSION_SOURCE"),
new File(Util.locateElasticsearchWorkspace(project.getGradle()), DEFAULT_VERSION_JAVA_FILE_PATH).getPath()
);
try (var is = new FileInputStream(versionsFilePath)) {
List<String> versionLines = IOUtils.readLines(is, "UTF-8");
return new BwcVersions(versionLines);
} catch (IOException e) {
@ -190,7 +203,7 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
}
}
private void logGlobalBuildInfo() {
private void logGlobalBuildInfo(BuildParameterExtension buildParams) {
final String osName = System.getProperty("os.name");
final String osVersion = System.getProperty("os.version");
final String osArch = System.getProperty("os.arch");
@ -202,14 +215,14 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
LOGGER.quiet("Elasticsearch Build Hamster says Hello!");
LOGGER.quiet(" Gradle Version : " + GradleVersion.current().getVersion());
LOGGER.quiet(" OS Info : " + osName + " " + osVersion + " (" + osArch + ")");
if (BuildParams.getIsRuntimeJavaHomeSet()) {
JvmInstallationMetadata runtimeJvm = metadataDetector.getMetadata(getJavaInstallation(BuildParams.getRuntimeJavaHome()));
if (buildParams.getIsRuntimeJavaHomeSet()) {
JvmInstallationMetadata runtimeJvm = metadataDetector.getMetadata(getJavaInstallation(buildParams.getRuntimeJavaHome().get()));
final String runtimeJvmVendorDetails = runtimeJvm.getVendor().getDisplayName();
final String runtimeJvmImplementationVersion = runtimeJvm.getJvmVersion();
final String runtimeVersion = runtimeJvm.getRuntimeVersion();
final String runtimeExtraDetails = runtimeJvmVendorDetails + ", " + runtimeVersion;
LOGGER.quiet(" Runtime JDK Version : " + runtimeJvmImplementationVersion + " (" + runtimeExtraDetails + ")");
LOGGER.quiet(" Runtime java.home : " + BuildParams.getRuntimeJavaHome());
LOGGER.quiet(" Runtime java.home : " + buildParams.getRuntimeJavaHome().get());
LOGGER.quiet(" Gradle JDK Version : " + gradleJvmImplementationVersion + " (" + gradleJvmVendorDetails + ")");
LOGGER.quiet(" Gradle java.home : " + gradleJvm.getJavaHome());
} else {
@ -220,8 +233,8 @@ public class GlobalBuildInfoPlugin implements Plugin<Project> {
if (javaToolchainHome != null) {
LOGGER.quiet(" JAVA_TOOLCHAIN_HOME : " + javaToolchainHome);
}
LOGGER.quiet(" Random Testing Seed : " + BuildParams.getTestSeed());
LOGGER.quiet(" In FIPS 140 mode : " + BuildParams.isInFipsJvm());
LOGGER.quiet(" Random Testing Seed : " + buildParams.getTestSeed());
LOGGER.quiet(" In FIPS 140 mode : " + buildParams.getInFipsJvm());
LOGGER.quiet("=======================================");
}

6
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/precommit/ForbiddenApisPrecommitPlugin.java
View file

@ -11,7 +11,7 @@ package org.elasticsearch.gradle.internal.precommit;
import org.elasticsearch.gradle.internal.ExportElasticsearchBuildResourcesTask;
import org.elasticsearch.gradle.internal.conventions.precommit.PrecommitPlugin;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.plugins.JavaBasePlugin;
@ -30,7 +30,7 @@ public class ForbiddenApisPrecommitPlugin extends PrecommitPlugin {
@Override
public TaskProvider<? extends Task> createTask(Project project) {
project.getPluginManager().apply(JavaBasePlugin.class);
var buildParams = project.getRootProject().getExtensions().getByType(BuildParameterExtension.class);
// Create a convenience task for all checks (this does not conflict with extension, as it has higher priority in DSL):
var forbiddenTask = project.getTasks()
.register(FORBIDDEN_APIS_TASK_NAME, task -> { task.setDescription("Runs forbidden-apis checks."); });
@ -57,7 +57,7 @@ public class ForbiddenApisPrecommitPlugin extends PrecommitPlugin {
t.setClassesDirs(sourceSet.getOutput().getClassesDirs());
t.dependsOn(resourcesTask);
t.setClasspath(sourceSet.getRuntimeClasspath().plus(sourceSet.getCompileClasspath()));
t.setTargetCompatibility(BuildParams.getMinimumRuntimeVersion().getMajorVersion());
t.setTargetCompatibility(buildParams.getMinimumRuntimeVersion().getMajorVersion());
t.getBundledSignatures().set(BUNDLED_SIGNATURE_DEFAULTS);
t.setSignaturesFiles(
project.files(

15
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/precommit/ThirdPartyAuditPrecommitPlugin.java
View file

@ -12,17 +12,19 @@ package org.elasticsearch.gradle.internal.precommit;
import org.elasticsearch.gradle.dependencies.CompileOnlyResolvePlugin;
import org.elasticsearch.gradle.internal.ExportElasticsearchBuildResourcesTask;
import org.elasticsearch.gradle.internal.conventions.precommit.PrecommitPlugin;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.TaskProvider;
import java.io.File;
import java.nio.file.Path;
import static org.elasticsearch.gradle.internal.util.DependenciesUtils.createFileCollectionFromNonTransitiveArtifactsView;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class ThirdPartyAuditPrecommitPlugin extends PrecommitPlugin {
@ -31,10 +33,14 @@ public class ThirdPartyAuditPrecommitPlugin extends PrecommitPlugin {
@Override
public TaskProvider<? extends Task> createTask(Project project) {
project.getRootProject().getPlugins().apply(CompileOnlyResolvePlugin.class);
Property<BuildParameterExtension> buildParams = loadBuildParams(project);
project.getPlugins().apply(CompileOnlyResolvePlugin.class);
project.getConfigurations().create("forbiddenApisCliJar");
project.getDependencies().add("forbiddenApisCliJar", "de.thetaphi:forbiddenapis:3.6");
Configuration jdkJarHellConfig = project.getConfigurations().create(JDK_JAR_HELL_CONFIG_NAME);
if (project.getPath().equals(LIBS_ELASTICSEARCH_CORE_PROJECT_PATH) == false) {
// Internal projects are not all plugins, so make sure the check is available
// we are not doing this for this project itself to avoid jar hell with itself
@ -66,9 +72,12 @@ public class ThirdPartyAuditPrecommitPlugin extends PrecommitPlugin {
&& ((ModuleComponentIdentifier) identifier).getGroup().startsWith("org.elasticsearch") == false
)
);
if (buildParams.get().getIsRuntimeJavaHomeSet()) {
t.getRuntimeJavaVersion().set(buildParams.get().getRuntimeJavaVersion());
}
t.dependsOn(resourcesTask);
t.getTargetCompatibility().set(project.provider(BuildParams::getRuntimeJavaVersion));
t.getJavaHome().set(project.provider(BuildParams::getRuntimeJavaHome).map(File::getPath));
t.getTargetCompatibility().set(buildParams.flatMap(params -> params.getRuntimeJavaVersion()));
t.getJavaHome().set(buildParams.flatMap(params -> params.getRuntimeJavaHome()).map(File::getPath));
t.setSignatureFile(resourcesDir.resolve("forbidden/third-party-audit.txt").toFile());
t.getJdkJarHellClasspath().from(jdkJarHellConfig);
t.getForbiddenAPIsClasspath().from(project.getConfigurations().getByName("forbiddenApisCliJar").plus(compileOnly));

15
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/precommit/ThirdPartyAuditTask.java
View file

@ -13,7 +13,6 @@ import de.thetaphi.forbiddenapis.cli.CliMain;
import org.apache.commons.io.output.NullOutputStream;
import org.elasticsearch.gradle.OS;
import org.elasticsearch.gradle.VersionProperties;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.gradle.api.DefaultTask;
import org.gradle.api.JavaVersion;
import org.gradle.api.file.ArchiveOperations;
@ -194,6 +193,10 @@ public abstract class ThirdPartyAuditTask extends DefaultTask {
@SkipWhenEmpty
public abstract ConfigurableFileCollection getJarsToScan();
@Input
@Optional
public abstract Property<JavaVersion> getRuntimeJavaVersion();
@Classpath
public FileCollection getClasspath() {
return classpath;
@ -371,14 +374,10 @@ public abstract class ThirdPartyAuditTask extends DefaultTask {
/** Returns true iff the build Java version is the same as the given version. */
private boolean isJavaVersion(JavaVersion version) {
if (BuildParams.getIsRuntimeJavaHomeSet()) {
if (version.equals(BuildParams.getRuntimeJavaVersion())) {
return true;
}
} else if (version.getMajorVersion().equals(VersionProperties.getBundledJdkMajorVersion())) {
return true;
if (getRuntimeJavaVersion().isPresent()) {
return getRuntimeJavaVersion().get().equals(version);
}
return false;
return version.getMajorVersion().equals(VersionProperties.getBundledJdkMajorVersion());
}
private Set<String> runJdkJarHellCheck() throws IOException {

8
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/snyk/GenerateSnykDependencyGraph.java
View file

@ -11,7 +11,6 @@ package org.elasticsearch.gradle.internal.snyk;
import groovy.json.JsonOutput;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.gradle.api.DefaultTask;
import org.gradle.api.GradleException;
import org.gradle.api.artifacts.Configuration;
@ -118,7 +117,7 @@ public class GenerateSnykDependencyGraph extends DefaultTask {
}
private Object buildTargetData() {
return Map.of("remoteUrl", remoteUrl.get(), "branch", BuildParams.getGitRevision());
return Map.of("remoteUrl", remoteUrl.get(), "branch", getGitRevision().get());
}
@InputFiles
@ -160,4 +159,9 @@ public class GenerateSnykDependencyGraph extends DefaultTask {
public Property<String> getTargetReference() {
return targetReference;
}
@Input
public Property<String> getGitRevision() {
return targetReference;
}
}

9
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/snyk/SnykDependencyMonitoringGradlePlugin.java
View file

@ -10,17 +10,22 @@
package org.elasticsearch.gradle.internal.snyk;
import org.elasticsearch.gradle.internal.conventions.info.GitInfo;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.file.ProjectLayout;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.tasks.SourceSet;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class SnykDependencyMonitoringGradlePlugin implements Plugin<Project> {
public static final String UPLOAD_TASK_NAME = "uploadSnykDependencyGraph";
@ -35,10 +40,14 @@ public class SnykDependencyMonitoringGradlePlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
Property<BuildParameterExtension> buildParams = loadBuildParams(project);
var generateTaskProvider = project.getTasks()
.register("generateSnykDependencyGraph", GenerateSnykDependencyGraph.class, generateSnykDependencyGraph -> {
generateSnykDependencyGraph.getProjectPath().set(project.getPath());
generateSnykDependencyGraph.getProjectName().set(project.getName());
generateSnykDependencyGraph.getGitRevision().set(buildParams.get().getGitRevision());
String projectVersion = project.getVersion().toString();
generateSnykDependencyGraph.getVersion().set(projectVersion);
generateSnykDependencyGraph.getGradleVersion().set(project.getGradle().getGradleVersion());

12
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/test/DistroTestPlugin.java
View file

@ -16,11 +16,11 @@ import org.elasticsearch.gradle.ElasticsearchDistribution.Platform;
import org.elasticsearch.gradle.ElasticsearchDistributionType;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.VersionProperties;
import org.elasticsearch.gradle.internal.BwcVersions;
import org.elasticsearch.gradle.internal.InternalDistributionDownloadPlugin;
import org.elasticsearch.gradle.internal.JdkDownloadPlugin;
import org.elasticsearch.gradle.internal.docker.DockerSupportPlugin;
import org.elasticsearch.gradle.internal.docker.DockerSupportService;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.test.SystemPropertyCommandLineArgumentProvider;
import org.elasticsearch.gradle.util.GradleUtils;
import org.gradle.api.Action;
@ -54,6 +54,7 @@ import static org.elasticsearch.gradle.internal.distribution.InternalElasticsear
import static org.elasticsearch.gradle.internal.distribution.InternalElasticsearchDistributionTypes.DOCKER_UBI;
import static org.elasticsearch.gradle.internal.distribution.InternalElasticsearchDistributionTypes.DOCKER_WOLFI;
import static org.elasticsearch.gradle.internal.distribution.InternalElasticsearchDistributionTypes.RPM;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* This class defines gradle tasks for testing our various distribution artifacts.
@ -72,6 +73,7 @@ public class DistroTestPlugin implements Plugin<Project> {
project.getPlugins().apply(InternalDistributionDownloadPlugin.class);
project.getPlugins().apply(JdkDownloadPlugin.class);
project.getPluginManager().apply("elasticsearch.java");
var buildParams = loadBuildParams(project).get();
Provider<DockerSupportService> dockerSupport = GradleUtils.getBuildService(
project.getGradle().getSharedServices(),
@ -84,7 +86,7 @@ public class DistroTestPlugin implements Plugin<Project> {
List<ElasticsearchDistribution> testDistributions = configureDistributions(project);
Map<ElasticsearchDistributionType, TaskProvider<?>> lifecycleTasks = lifecycleTasks(project, "destructiveDistroTest");
Map<String, TaskProvider<?>> versionTasks = versionTasks(project, "destructiveDistroUpgradeTest");
Map<String, TaskProvider<?>> versionTasks = versionTasks(project, "destructiveDistroUpgradeTest", buildParams.getBwcVersions());
TaskProvider<Task> destructiveDistroTest = project.getTasks().register("destructiveDistroTest");
Configuration examplePlugin = configureExamplePlugin(project);
@ -115,7 +117,7 @@ public class DistroTestPlugin implements Plugin<Project> {
lifecycleTask.configure(t -> t.dependsOn(destructiveTask));
if ((type == DEB || type == RPM) && distribution.getBundledJdk()) {
for (Version version : BuildParams.getBwcVersions().getIndexCompatible()) {
for (Version version : buildParams.getBwcVersions().getIndexCompatible()) {
final ElasticsearchDistribution bwcDistro;
if (version.equals(Version.fromString(distribution.getVersion()))) {
// this is the same as the distribution we are testing
@ -156,10 +158,10 @@ public class DistroTestPlugin implements Plugin<Project> {
return lifecyleTasks;
}
private static Map<String, TaskProvider<?>> versionTasks(Project project, String taskPrefix) {
private static Map<String, TaskProvider<?>> versionTasks(Project project, String taskPrefix, BwcVersions bwcVersions) {
Map<String, TaskProvider<?>> versionTasks = new HashMap<>();
for (Version version : BuildParams.getBwcVersions().getIndexCompatible()) {
for (Version version : bwcVersions.getIndexCompatible()) {
versionTasks.put(version.toString(), project.getTasks().register(taskPrefix + ".v" + version));
}

9
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/test/InternalClusterTestPlugin.java
View file

@ -9,7 +9,7 @@
package org.elasticsearch.gradle.internal.test;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.util.GradleUtils;
import org.gradle.api.JavaVersion;
import org.gradle.api.Plugin;
@ -18,16 +18,21 @@ import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.testing.Test;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class InternalClusterTestPlugin implements Plugin<Project> {
public static final String SOURCE_SET_NAME = "internalClusterTest";
@Override
public void apply(Project project) {
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
var buildParams = loadBuildParams(project).get();
TaskProvider<Test> internalClusterTest = GradleUtils.addTestSourceSet(project, SOURCE_SET_NAME);
internalClusterTest.configure(task -> {
// Set GC options to mirror defaults in jvm.options
if (BuildParams.getRuntimeJavaVersion().compareTo(JavaVersion.VERSION_14) < 0) {
if (buildParams.getRuntimeJavaVersion().get().compareTo(JavaVersion.VERSION_14) < 0) {
task.jvmArgs("-XX:+UseConcMarkSweepGC", "-XX:CMSInitiatingOccupancyFraction=75", "-XX:+UseCMSInitiatingOccupancyOnly");
} else {
task.jvmArgs("-XX:+UseG1GC");

9
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/test/MutedTestPlugin.java
View file

@ -9,7 +9,7 @@
package org.elasticsearch.gradle.internal.test;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.file.RegularFile;
@ -19,6 +19,8 @@ import org.gradle.api.tasks.testing.Test;
import java.util.Arrays;
import java.util.List;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class MutedTestPlugin implements Plugin<Project> {
private static final String ADDITIONAL_FILES_PROPERTY = "org.elasticsearch.additional.muted.tests";
@ -32,6 +34,9 @@ public class MutedTestPlugin implements Plugin<Project> {
.map(p -> project.getRootProject().getLayout().getProjectDirectory().file(p))
.toList();
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
var buildParams = loadBuildParams(project).get();
Provider<MutedTestsBuildService> mutedTestsProvider = project.getGradle()
.getSharedServices()
.registerIfAbsent("mutedTests", MutedTestsBuildService.class, spec -> {
@ -46,7 +51,7 @@ public class MutedTestPlugin implements Plugin<Project> {
}
// Don't fail when all tests are ignored when running in CI
filter.setFailOnNoMatchingTests(BuildParams.isCi() == false);
filter.setFailOnNoMatchingTests(buildParams.isCi() == false);
});
});
}

5
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/test/TestWithSslPlugin.java
View file

@ -11,7 +11,7 @@ package org.elasticsearch.gradle.internal.test;
import org.elasticsearch.gradle.internal.ExportElasticsearchBuildResourcesTask;
import org.elasticsearch.gradle.internal.conventions.util.Util;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.precommit.FilePermissionsPrecommitPlugin;
import org.elasticsearch.gradle.internal.precommit.ForbiddenPatternsPrecommitPlugin;
import org.elasticsearch.gradle.internal.precommit.ForbiddenPatternsTask;
@ -35,6 +35,7 @@ public class TestWithSslPlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
File keyStoreDir = new File(project.getBuildDir(), "keystore");
BuildParameterExtension buildParams = project.getRootProject().getExtensions().getByType(BuildParameterExtension.class);
TaskProvider<ExportElasticsearchBuildResourcesTask> exportKeyStore = project.getTasks()
.register("copyTestCertificates", ExportElasticsearchBuildResourcesTask.class, (t) -> {
t.copy("test/ssl/test-client.crt");
@ -87,7 +88,7 @@ public class TestWithSslPlugin implements Plugin<Project> {
.getExtensions()
.getByName(TestClustersPlugin.EXTENSION_NAME);
clusters.configureEach(c -> {
if (BuildParams.isInFipsJvm()) {
if (buildParams.getInFipsJvm()) {
c.setting("xpack.security.transport.ssl.key", "test-node.key");
c.keystore("xpack.security.transport.ssl.secure_key_passphrase", "test-node-key-password");
c.setting("xpack.security.transport.ssl.certificate", "test-node.crt");

12
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/test/rest/RestTestBasePlugin.java
View file

@ -20,7 +20,6 @@ import org.elasticsearch.gradle.VersionProperties;
import org.elasticsearch.gradle.distribution.ElasticsearchDistributionTypes;
import org.elasticsearch.gradle.internal.ElasticsearchJavaBasePlugin;
import org.elasticsearch.gradle.internal.InternalDistributionDownloadPlugin;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.test.ErrorReportingTestListener;
import org.elasticsearch.gradle.internal.test.HistoricalFeaturesMetadataPlugin;
import org.elasticsearch.gradle.plugin.BasePluginBuildPlugin;
@ -58,6 +57,8 @@ import java.util.Optional;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* Base plugin used for wiring up build tasks to REST testing tasks using new JUnit rule-based test clusters framework.
*/
@ -92,6 +93,7 @@ public class RestTestBasePlugin implements Plugin<Project> {
public void apply(Project project) {
project.getPluginManager().apply(ElasticsearchJavaBasePlugin.class);
project.getPluginManager().apply(InternalDistributionDownloadPlugin.class);
var bwcVersions = loadBuildParams(project).get().getBwcVersions();
// Register integ-test and default distributions
ElasticsearchDistribution defaultDistro = createDistribution(
@ -176,7 +178,7 @@ public class RestTestBasePlugin implements Plugin<Project> {
task.systemProperty("tests.system_call_filter", "false");
// Pass minimum wire compatible version which is used by upgrade tests
task.systemProperty(MINIMUM_WIRE_COMPATIBLE_VERSION_SYSPROP, BuildParams.getBwcVersions().getMinimumWireCompatibleVersion());
task.systemProperty(MINIMUM_WIRE_COMPATIBLE_VERSION_SYSPROP, bwcVersions.getMinimumWireCompatibleVersion());
// Register plugins and modules as task inputs and pass paths as system properties to tests
var modulePath = project.getObjects().fileCollection().from(modulesConfiguration);
@ -223,7 +225,7 @@ public class RestTestBasePlugin implements Plugin<Project> {
}
Version version = (Version) args[0];
boolean isReleased = BuildParams.getBwcVersions().unreleasedInfo(version) == null;
boolean isReleased = bwcVersions.unreleasedInfo(version) == null;
String versionString = version.toString();
ElasticsearchDistribution bwcDistro = createDistribution(project, "bwc_" + versionString, versionString);
@ -235,9 +237,9 @@ public class RestTestBasePlugin implements Plugin<Project> {
providerFactory.provider(() -> bwcDistro.getExtracted().getSingleFile().getPath())
);
if (version.getMajor() > 0 && version.before(BuildParams.getBwcVersions().getMinimumWireCompatibleVersion())) {
if (version.getMajor() > 0 && version.before(bwcVersions.getMinimumWireCompatibleVersion())) {
// If we are upgrade testing older versions we also need to upgrade to 7.last
this.call(BuildParams.getBwcVersions().getMinimumWireCompatibleVersion());
this.call(bwcVersions.getMinimumWireCompatibleVersion());
}
return null;
}

12
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/test/rest/compat/compat/AbstractYamlRestCompatTestPlugin.java
View file

@ -11,7 +11,8 @@ package org.elasticsearch.gradle.internal.test.rest.compat.compat;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.internal.ElasticsearchJavaBasePlugin;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.internal.test.rest.CopyRestApiTask;
import org.elasticsearch.gradle.internal.test.rest.CopyRestTestsTask;
import org.elasticsearch.gradle.internal.test.rest.LegacyYamlRestTestPlugin;
@ -47,6 +48,7 @@ import java.util.Map;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.test.rest.RestTestUtil.setupYamlRestTestDependenciesDefaults;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
/**
* Apply this plugin to run the YAML based REST tests from a prior major version against this version's cluster.
@ -74,6 +76,8 @@ public abstract class AbstractYamlRestCompatTestPlugin implements Plugin<Project
@Override
public void apply(Project project) {
project.getRootProject().getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
BuildParameterExtension buildParams = loadBuildParams(project).get();
final Path compatRestResourcesDir = Path.of("restResources").resolve("compat");
final Path compatSpecsDir = compatRestResourcesDir.resolve("yamlSpecs");
@ -91,14 +95,14 @@ public abstract class AbstractYamlRestCompatTestPlugin implements Plugin<Project
GradleUtils.extendSourceSet(project, YamlRestTestPlugin.YAML_REST_TEST, SOURCE_SET_NAME);
// determine the previous rest compatibility version and BWC project path
int currentMajor = BuildParams.getBwcVersions().getCurrentVersion().getMajor();
Version lastMinor = BuildParams.getBwcVersions()
int currentMajor = buildParams.getBwcVersions().getCurrentVersion().getMajor();
Version lastMinor = buildParams.getBwcVersions()
.getUnreleased()
.stream()
.filter(v -> v.getMajor() == currentMajor - 1)
.min(Comparator.reverseOrder())
.get();
String lastMinorProjectPath = BuildParams.getBwcVersions().unreleasedInfo(lastMinor).gradleProjectPath();
String lastMinorProjectPath = buildParams.getBwcVersions().unreleasedInfo(lastMinor).gradleProjectPath();
// copy compatible rest specs
Configuration bwcMinorConfig = project.getConfigurations().create(BWC_MINOR_CONFIG_NAME);

18
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/testfixtures/TestFixturesDeployPlugin.java
View file

@ -12,7 +12,7 @@ package org.elasticsearch.gradle.internal.testfixtures;
import org.apache.commons.lang.StringUtils;
import org.elasticsearch.gradle.Architecture;
import org.elasticsearch.gradle.internal.docker.DockerBuildTask;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.NamedDomainObjectContainer;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
@ -20,6 +20,8 @@ import org.gradle.api.Project;
import java.util.Arrays;
import java.util.List;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class TestFixturesDeployPlugin implements Plugin<Project> {
public static final String DEPLOY_FIXTURE_TASK_NAME = "deployFixtureDockerImages";
@ -27,13 +29,19 @@ public class TestFixturesDeployPlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
var buildParams = loadBuildParams(project).get();
NamedDomainObjectContainer<TestFixtureDeployment> fixtures = project.container(TestFixtureDeployment.class);
project.getExtensions().add("dockerFixtures", fixtures);
registerDeployTaskPerFixture(project, fixtures);
registerDeployTaskPerFixture(project, fixtures, buildParams.isCi());
project.getTasks().register(DEPLOY_FIXTURE_TASK_NAME, task -> task.dependsOn(project.getTasks().withType(DockerBuildTask.class)));
}
private static void registerDeployTaskPerFixture(Project project, NamedDomainObjectContainer<TestFixtureDeployment> fixtures) {
private static void registerDeployTaskPerFixture(
Project project,
NamedDomainObjectContainer<TestFixtureDeployment> fixtures,
boolean isCi
) {
fixtures.all(
fixture -> project.getTasks()
.register("deploy" + StringUtils.capitalize(fixture.getName()) + "DockerImage", DockerBuildTask.class, task -> {
@ -42,12 +50,12 @@ public class TestFixturesDeployPlugin implements Plugin<Project> {
if (baseImages.isEmpty() == false) {
task.setBaseImages(baseImages.toArray(new String[baseImages.size()]));
}
task.setNoCache(BuildParams.isCi());
task.setNoCache(isCi);
task.setTags(
new String[] {
resolveTargetDockerRegistry(fixture) + "/" + fixture.getName() + "-fixture:" + fixture.getVersion().get() }
);
task.getPush().set(BuildParams.isCi());
task.getPush().set(isCi);
task.getPlatforms().addAll(Arrays.stream(Architecture.values()).map(a -> a.dockerPlatform).toList());
task.setGroup("Deploy TestFixtures");
task.setDescription("Deploys the " + fixture.getName() + " test fixture");

8
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/testfixtures/TestFixturesPlugin.java
View file

@ -17,7 +17,7 @@ import com.avast.gradle.dockercompose.tasks.ComposeUp;
import org.elasticsearch.gradle.internal.docker.DockerSupportPlugin;
import org.elasticsearch.gradle.internal.docker.DockerSupportService;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.elasticsearch.gradle.test.SystemPropertyCommandLineArgumentProvider;
import org.elasticsearch.gradle.util.GradleUtils;
import org.gradle.api.Action;
@ -47,6 +47,8 @@ import java.util.function.BiConsumer;
import javax.inject.Inject;
import static org.elasticsearch.gradle.internal.util.ParamsUtils.loadBuildParams;
public class TestFixturesPlugin implements Plugin<Project> {
private static final Logger LOGGER = Logging.getLogger(TestFixturesPlugin.class);
@ -68,6 +70,8 @@ public class TestFixturesPlugin implements Plugin<Project> {
@Override
public void apply(Project project) {
project.getRootProject().getPluginManager().apply(DockerSupportPlugin.class);
project.getRootProject().getPlugins().apply(GlobalBuildInfoPlugin.class);
var buildParams = loadBuildParams(project).get();
TaskContainer tasks = project.getTasks();
Provider<DockerComposeThrottle> dockerComposeThrottle = project.getGradle()
@ -127,7 +131,7 @@ public class TestFixturesPlugin implements Plugin<Project> {
tasks.withType(ComposeUp.class).named("composeUp").configure(t -> {
// Avoid running docker-compose tasks in parallel in CI due to some issues on certain Linux distributions
if (BuildParams.isCi()) {
if (buildParams.isCi()) {
t.usesService(dockerComposeThrottle);
t.usesService(dockerSupport);
}

28
build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/util/ParamsUtils.java Normal file
View file

@ -0,0 +1,28 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the "Elastic License
* 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
* Public License v 1"; you may not use this file except in compliance with, at
* your election, the "Elastic License 2.0", the "GNU Affero General Public
* License v3.0 only", or the "Server Side Public License, v 1".
*/
package org.elasticsearch.gradle.internal.util;
import org.elasticsearch.gradle.internal.info.BuildParameterExtension;
import org.elasticsearch.gradle.internal.info.BuildParameterService;
import org.gradle.api.Project;
import org.gradle.api.provider.Property;
import org.gradle.api.services.BuildServiceRegistration;
public class ParamsUtils {
public static Property<BuildParameterExtension> loadBuildParams(Project project) {
BuildServiceRegistration<BuildParameterService, BuildParameterService.Params> buildParamsRegistrations = (BuildServiceRegistration<
BuildParameterService,
BuildParameterService.Params>) project.getGradle().getSharedServices().getRegistrations().getByName("buildParams");
Property<BuildParameterExtension> buildParams = buildParamsRegistrations.getParameters().getBuildParams();
return buildParams;
}
}

3
build-tools/src/testFixtures/groovy/org/elasticsearch/gradle/fixtures/AbstractGradleFuncTest.groovy
View file

@ -168,7 +168,6 @@ abstract class AbstractGradleFuncTest extends Specification {
${extraPlugins.collect { p -> "id '$p'" }.join('\n')}
}
import org.elasticsearch.gradle.Architecture
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.internal.BwcVersions
import org.elasticsearch.gradle.Version
@ -182,7 +181,7 @@ abstract class AbstractGradleFuncTest extends Specification {
]
BwcVersions versions = new BwcVersions(currentVersion, versionList)
BuildParams.init { it.setBwcVersions(provider(() -> versions)) }
buildParams.getBwcVersionsProperty().set(versions)
"""
}

21
build.gradle
View file

@ -17,7 +17,6 @@ import org.elasticsearch.gradle.DistributionDownloadPlugin
import org.elasticsearch.gradle.Version
import org.elasticsearch.gradle.internal.BaseInternalPluginBuildPlugin
import org.elasticsearch.gradle.internal.ResolveAllDependencies
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.util.GradleUtils
import org.gradle.plugins.ide.eclipse.model.AccessRule
@ -143,23 +142,23 @@ tasks.register("updateCIBwcVersions") {
}
doLast {
writeVersions(file(".ci/bwcVersions"), filterIntermediatePatches(BuildParams.bwcVersions.indexCompatible))
writeVersions(file(".ci/snapshotBwcVersions"), filterIntermediatePatches(BuildParams.bwcVersions.unreleasedIndexCompatible))
writeVersions(file(".ci/bwcVersions"), filterIntermediatePatches(buildParams.bwcVersions.indexCompatible))
writeVersions(file(".ci/snapshotBwcVersions"), filterIntermediatePatches(buildParams.bwcVersions.unreleasedIndexCompatible))
expandBwcList(
".buildkite/pipelines/intake.yml",
".buildkite/pipelines/intake.template.yml",
filterIntermediatePatches(BuildParams.bwcVersions.unreleasedIndexCompatible)
filterIntermediatePatches(buildParams.bwcVersions.unreleasedIndexCompatible)
)
writeBuildkitePipeline(
".buildkite/pipelines/periodic.yml",
".buildkite/pipelines/periodic.template.yml",
[
new ListExpansion(versions: filterIntermediatePatches(BuildParams.bwcVersions.unreleasedIndexCompatible), variable: "BWC_LIST"),
new ListExpansion(versions: filterIntermediatePatches(buildParams.bwcVersions.unreleasedIndexCompatible), variable: "BWC_LIST"),
],
[
new StepExpansion(
templatePath: ".buildkite/pipelines/periodic.bwc.template.yml",
versions: filterIntermediatePatches(BuildParams.bwcVersions.indexCompatible),
versions: filterIntermediatePatches(buildParams.bwcVersions.indexCompatible),
variable: "BWC_STEPS"
),
]
@ -169,7 +168,7 @@ tasks.register("updateCIBwcVersions") {
".buildkite/pipelines/periodic-packaging.yml",
".buildkite/pipelines/periodic-packaging.template.yml",
".buildkite/pipelines/periodic-packaging.bwc.template.yml",
filterIntermediatePatches(BuildParams.bwcVersions.indexCompatible)
filterIntermediatePatches(buildParams.bwcVersions.indexCompatible)
)
}
}
@ -191,19 +190,19 @@ tasks.register("verifyVersions") {
// Fetch the metadata and parse the xml into Version instances because it's more straight forward here
// rather than bwcVersion ( VersionCollection ).
new URL('https://repo1.maven.org/maven2/org/elasticsearch/elasticsearch/maven-metadata.xml').openStream().withStream { s ->
BuildParams.bwcVersions.compareToAuthoritative(
buildParams.bwcVersions.compareToAuthoritative(
new XmlParser().parse(s)
.versioning.versions.version
.collect { it.text() }.findAll { it ==~ /\d+\.\d+\.\d+/ }
.collect { Version.fromString(it) }
)
}
verifyCiYaml(file(".ci/bwcVersions"), filterIntermediatePatches(BuildParams.bwcVersions.indexCompatible))
verifyCiYaml(file(".ci/snapshotBwcVersions"), BuildParams.bwcVersions.unreleasedIndexCompatible)
verifyCiYaml(file(".ci/bwcVersions"), filterIntermediatePatches(buildParams.bwcVersions.indexCompatible))
verifyCiYaml(file(".ci/snapshotBwcVersions"), buildParams.bwcVersions.unreleasedIndexCompatible)
// Make sure backport bot config file is up to date
JsonNode backportConfig = new ObjectMapper().readTree(file(".backportrc.json"))
BuildParams.bwcVersions.forPreviousUnreleased { unreleasedVersion ->
buildParams.bwcVersions.forPreviousUnreleased { unreleasedVersion ->
boolean valid = backportConfig.get("targetBranchChoices").elements().any { branchChoice ->
if (branchChoice.isObject()) {
return branchChoice.get("name").textValue() == unreleasedVersion.branch

5
distribution/build.gradle
View file

@ -14,7 +14,6 @@ import org.elasticsearch.gradle.VersionProperties
import org.elasticsearch.gradle.internal.ConcatFilesTask
import org.elasticsearch.gradle.internal.DependenciesInfoPlugin
import org.elasticsearch.gradle.internal.NoticeTask
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.internal.test.HistoricalFeaturesMetadataPlugin
import java.nio.file.Files
@ -208,7 +207,7 @@ project.rootProject.subprojects.findAll { it.parent.path == ':modules' }.each {
distro.copyModule(processDefaultOutputsTaskProvider, module)
dependencies.add('featuresMetadata', module)
if (module.name.startsWith('transport-') || (BuildParams.snapshotBuild == false && module.name == 'apm')) {
if (module.name.startsWith('transport-') || (buildParams.snapshotBuild == false && module.name == 'apm')) {
distro.copyModule(processIntegTestOutputsTaskProvider, module)
}
@ -378,7 +377,7 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
exclude "**/platform/${excludePlatform}/**"
}
}
if (BuildParams.isSnapshotBuild()) {
if (buildParams.isSnapshotBuild()) {
from(buildExternalTestModulesTaskProvider)
}
if (project.path.startsWith(':distribution:packages')) {

9
distribution/docker/build.gradle
View file

@ -8,7 +8,6 @@ import org.elasticsearch.gradle.internal.docker.DockerSupportService
import org.elasticsearch.gradle.internal.docker.ShellRetry
import org.elasticsearch.gradle.internal.docker.TransformLog4jConfigFilter
import org.elasticsearch.gradle.internal.docker.*
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.util.GradleUtils
import org.elasticsearch.gradle.Architecture
import java.nio.file.Path
@ -120,7 +119,7 @@ ext.expansions = { Architecture architecture, DockerBase base ->
// the image. When developing the Docker images, it's very tedious to completely rebuild
// an image for every single change. Therefore, outside of CI, we fix the
// build time to midnight so that the Docker build cache is usable.
def buildDate = BuildParams.isCi() ? BuildParams.buildDate : BuildParams.buildDate.truncatedTo(ChronoUnit.DAYS).toString()
def buildDate = buildParams.isCi() ? buildParams.buildDate : buildParams.buildDate.truncatedTo(ChronoUnit.DAYS).toString()
return [
'arch' : architecture.classifier,
@ -128,7 +127,7 @@ ext.expansions = { Architecture architecture, DockerBase base ->
'bin_dir' : base == DockerBase.IRON_BANK ? 'scripts' : 'bin',
'build_date' : buildDate,
'config_dir' : base == DockerBase.IRON_BANK ? 'scripts' : 'config',
'git_revision' : BuildParams.gitRevision,
'git_revision' : buildParams.gitRevision,
'license' : base == DockerBase.IRON_BANK ? 'Elastic License 2.0' : 'Elastic-License-2.0',
'package_manager' : base.packageManager,
'docker_base' : base.name().toLowerCase(),
@ -390,7 +389,7 @@ void addBuildDockerImageTask(Architecture architecture, DockerBase base) {
dockerContext.fileProvider(transformTask.map { Sync task -> task.getDestinationDir() })
noCache = BuildParams.isCi()
noCache = buildParams.isCi()
tags = generateTags(base, architecture)
platforms.add(architecture.dockerPlatform)
@ -485,7 +484,7 @@ void addBuildEssDockerImageTask(Architecture architecture) {
dockerContext.fileProvider(buildContextTask.map { it.getDestinationDir() })
noCache = BuildParams.isCi()
noCache = buildParams.isCi()
baseImages = []
tags = generateTags(dockerBase, architecture)
platforms.add(architecture.dockerPlatform)

2
distribution/packages/build.gradle
View file

@ -301,7 +301,7 @@ ospackage {
url 'https://www.elastic.co/'
// signing setup
if (project.hasProperty('signing.password') && BuildParams.isSnapshotBuild() == false) {
if (project.hasProperty('signing.password') && buildParams.isSnapshotBuild() == false) {
signingKeyId = project.hasProperty('signing.keyId') ? project.property('signing.keyId') : 'D88E42B4'
signingKeyPassphrase = project.property('signing.password')
signingKeyRingFile = project.hasProperty('signing.secretKeyRingFile') ?

9
docs/build.gradle
View file

@ -1,5 +1,4 @@
import org.elasticsearch.gradle.Version
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.internal.doc.DocSnippetTask
import static org.elasticsearch.gradle.testclusters.TestDistribution.DEFAULT
@ -29,7 +28,7 @@ ext.docsFileTree = fileTree(projectDir) {
// These files simply don't pass yet. We should figure out how to fix them.
exclude 'reference/watcher/reference/actions.asciidoc'
exclude 'reference/rest-api/security/ssl.asciidoc'
if (BuildParams.inFipsJvm) {
if (buildParams.inFipsJvm) {
// We don't support this component in FIPS 140
exclude 'reference/ingest/processors/attachment.asciidoc'
// We can't conditionally control output, this would be missing the ingest-attachment component
@ -38,7 +37,7 @@ ext.docsFileTree = fileTree(projectDir) {
}
tasks.named("yamlRestTest") {
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
// LOOKUP is not available in snapshots
systemProperty 'tests.rest.blacklist', [
"reference/esql/processing-commands/lookup/esql-lookup-example"
@ -83,7 +82,7 @@ testClusters.matching { it.name == "yamlRestTest"}.configureEach {
setting 'xpack.license.self_generated.type', 'trial'
setting 'indices.lifecycle.history_index_enabled', 'false'
keystorePassword 'keystore-password'
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
requiresFeature 'es.failure_store_feature_flag_enabled', new Version(8, 12, 0)
}
}
@ -170,7 +169,7 @@ testClusters.matching { it.name == "yamlRestTest"}.configureEach {
return
}
// Do not install ingest-attachment in a FIPS 140 JVM as this is not supported
if (subproj.path.startsWith(':modules:ingest-attachment') && BuildParams.inFipsJvm) {
if (subproj.path.startsWith(':modules:ingest-attachment') && buildParams.inFipsJvm) {
return
}
plugin subproj.path

2
gradle.properties
View file

@ -2,7 +2,7 @@ org.gradle.welcome=never
org.gradle.warning.mode=none
org.gradle.parallel=true
# We need to declare --add-exports to make spotless working seamlessly with jdk16
org.gradle.jvmargs=-XX:+HeapDumpOnOutOfMemoryError -Xss2m --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
org.gradle.jvmargs=-XX:+HeapDumpOnOutOfMemoryError -Xss2m --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-opens java.base/java.time=ALL-UNNAMED
# Enforce the build to fail on deprecated gradle api usage
systemProp.org.gradle.warning.mode=fail

135
gradle/verification-metadata.xml
View file

@ -219,6 +219,11 @@
<sha256 value="6b531c6b4be581a8b32ead861ddc15c2c93b20c665fb4d33e0381483c24445f4" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.durian" name="durian-swt.os" version="4.3.0">
<artifact name="durian-swt.os-4.3.0.jar">
<sha256 value="81e2b639a7e4be6dc9b7245713cf06f5cab51f29db2e16b9b57645c96fde2884" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.spotless" name="spotless-eclipse-base" version="3.5.2">
<artifact name="spotless-eclipse-base-3.5.2.jar">
<sha256 value="e381d6996a3d7f41c02d79bd0b1dff077aaec40b55fa15971c1bb45ab16f5a20" origin="Generated by Gradle"/>
@ -234,16 +239,31 @@
<sha256 value="b25969972e1d980280ca2ae529197ed9b3160aae48b506cf1935f01bd1318667" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.spotless" name="spotless-lib" version="3.0.0.BETA3">
<artifact name="spotless-lib-3.0.0.BETA3.jar">
<sha256 value="caa88246e4f3b4d26e4c4b24b31db33a6758747429f6429702ab8dd75bd58e90" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.spotless" name="spotless-lib-extra" version="2.45.0">
<artifact name="spotless-lib-extra-2.45.0.jar">
<sha256 value="602cbbcd3828ee9cfb2e30a7f9b30335c6927130771414d4cdd294d21fe5cb67" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.spotless" name="spotless-lib-extra" version="3.0.0.BETA3">
<artifact name="spotless-lib-extra-3.0.0.BETA3.jar">
<sha256 value="58e3ddd55199ad74c28fa6490bad1e2b707d7aa4694d3611af2394af77fa2212" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.spotless" name="spotless-plugin-gradle" version="6.25.0">
<artifact name="spotless-plugin-gradle-6.25.0.jar">
<sha256 value="f5eb908a4c5da46299e7543faada0402d2c4b77d58c7b432d4b6e59349b280a3" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.diffplug.spotless" name="spotless-plugin-gradle" version="7.0.0.BETA3">
<artifact name="spotless-plugin-gradle-7.0.0.BETA3.jar">
<sha256 value="a3609eeb7173837a589a4ad865e6feaf71ee6139d061eae2e698401485f7589c" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.ethlo.time" name="itu" version="1.7.0">
<artifact name="itu-1.7.0.jar">
<sha256 value="55ceb418c9e8138c4fcf62e213c4c814d89e8a84c827d395407cbecba5d791e7" origin="Generated by Gradle"/>
@ -614,6 +634,11 @@
<sha256 value="bac84458eb12499585f2fabb1ac13bbe5b455c120bf3d19db21597814a27c863" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.google.googlejavaformat" name="google-java-format" version="1.24.0">
<artifact name="google-java-format-1.24.0.jar">
<sha256 value="9a4e0b9f4ec4d71a8a1d3641fd481118100fda2eeab712dbdfd4b2a06e9de4ce" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="com.google.guava" name="failureaccess" version="1.0">
<artifact name="failureaccess-1.0.jar">
<sha256 value="d084bef9cd07a8537a1753e4850a69b7e8bab1d1e22e9f3a1e4826309a7a2336" origin="Generated by Gradle"/>
@ -1196,6 +1221,11 @@
<sha256 value="ec87bfb55f22cbd1b21e2190eeda28b2b312ed2a431ee49fbdcc01812d04a5e4" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="commons-codec" name="commons-codec" version="1.17.0">
<artifact name="commons-codec-1.17.0.jar">
<sha256 value="f700de80ac270d0344fdea7468201d8b9c805e5c648331c3619f2ee067ccfc59" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="commons-codec" name="commons-codec" version="1.9">
<artifact name="commons-codec-1.9.jar">
<sha256 value="ad19d2601c3abf0b946b5c3a4113e226a8c1e3305e395b90013b78dd94a723ce" origin="Generated by Gradle"/>
@ -1311,6 +1341,11 @@
<sha256 value="06e14bc43acc331dab6b5ea201fc67364ed123f982c85fa5131f0817ed65ae4f" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="dev.equo.ide" name="solstice" version="1.8.0">
<artifact name="solstice-1.8.0.jar">
<sha256 value="cc272e742da41a326623a83ec1b086832fe80869cbf0a19627887f1fb128312c" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="dnsjava" name="dnsjava" version="2.1.7">
<artifact name="dnsjava-2.1.7.jar">
<sha256 value="2c52a6fabd5af9331d73fc7787dafc32a56bd8019c49f89749c2eeef244e303c" origin="Generated by Gradle"/>
@ -2282,6 +2317,11 @@
<sha256 value="f2354b8207926be80debb9edd3108cd0b86eff8e4fe22a9244f214723f96d28e" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.apache.felix" name="org.apache.felix.scr" version="2.2.10">
<artifact name="org.apache.felix.scr-2.2.10.jar">
<sha256 value="dd9d920101890ecd0565a8e48bf3f80bbe3d398cdf0f1970a19eec4f54c8d4e1" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.apache.felix" name="org.apache.felix.scr" version="2.2.6">
<artifact name="org.apache.felix.scr-2.2.6.jar">
<sha256 value="24c0b2d8081cbc9624e60a1c19f1dd0d104e014cdba4038d9b1aed0ab63721c6" origin="Generated by Gradle"/>
@ -3423,11 +3463,21 @@
<sha256 value="b89df382369f2d16b19b67085426dc0fb7401fe1ad9fba1806af4e9729f5d1c0" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.jdt" name="ecj" version="3.38.0">
<artifact name="ecj-3.38.0.jar">
<sha256 value="97c566b120009c203a2fc8b291f4a9adbc171cf1ccb70f06f6b4e1828c00ce8e" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.jdt" name="org.eclipse.jdt.core" version="3.35.0">
<artifact name="org.eclipse.jdt.core-3.35.0.jar">
<sha256 value="8f5bcb00355b271638b9d82a8cccd0e733225cb74c4a3f0f55a7b75d43ee442a" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.jdt" name="org.eclipse.jdt.core" version="3.38.0">
<artifact name="org.eclipse.jdt.core-3.38.0.jar">
<sha256 value="f0387e80ed4327d39f1f63da8773ee460af4edd78f7c2efecb4ba9bc0628bf60" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.jetty" name="jetty-annotations" version="9.4.40.v20210413">
<artifact name="jetty-annotations-9.4.40.v20210413.jar">
<sha256 value="faccdc2113daf5ace9157cacd98751a41280fec94f584fd571b7fc26ff84742d" origin="Generated by Gradle"/>
@ -3533,6 +3583,11 @@
<sha256 value="d679365a6c8e55c1496701099f5e5765433f68dcb659759416ba5b222eb5055c" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.jgit" name="org.eclipse.jgit" version="6.10.0.202406032230-r">
<artifact name="org.eclipse.jgit-6.10.0.202406032230-r.jar">
<sha256 value="43f92f3adb681a5f3006b979e8d341c12a8cfd8029f287c42bcf0a80377565ae" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.jgit" name="org.eclipse.jgit" version="6.5.0.202303070854-r">
<artifact name="org.eclipse.jgit-6.5.0.202303070854-r.jar">
<sha256 value="9b4da8cde1651fa7a9f4d242585fe94343d40165e4c06ad5a722044a2cbe6251" origin="Generated by Gradle"/>
@ -3548,66 +3603,131 @@
<sha256 value="97a503e4c7711e93e0724cb5181eab8a3cb926fbe0a00ab84f13e69e1d156378" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.commands" version="3.12.100">
<artifact name="org.eclipse.core.commands-3.12.100.jar">
<sha256 value="443adcdec30c0563e4d7bafe6f7eeca704749e4b5a8620d18626fb1d640b41f7" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.contenttype" version="3.9.100">
<artifact name="org.eclipse.core.contenttype-3.9.100.jar">
<sha256 value="707e81707e8f2843be90f621aa3b7ff318dd3244e6f4a2982af55f66faf55987" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.contenttype" version="3.9.400">
<artifact name="org.eclipse.core.contenttype-3.9.400.jar">
<sha256 value="7622d903f85e8c11afe6ae662ffa1a2c33a5f694c6510758299f070ec520d4ca" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.expressions" version="3.9.100">
<artifact name="org.eclipse.core.expressions-3.9.100.jar">
<sha256 value="72736638d17cef9183659590d99fd7262a601ed2e3723295737a638db24e23fd" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.expressions" version="3.9.400">
<artifact name="org.eclipse.core.expressions-3.9.400.jar">
<sha256 value="2d8ef98092c1260b6b7743c762a4b1cc4b1679f8fbbb94e1d254d91ca232bd49" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.filesystem" version="1.10.100">
<artifact name="org.eclipse.core.filesystem-1.10.100.jar">
<sha256 value="fb9c03bde38e2cfe2d5e32c4ed858e824882cec07e911ae5de2322bd33e6a0a2" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.filesystem" version="1.10.400">
<artifact name="org.eclipse.core.filesystem-1.10.400.jar">
<sha256 value="7cfc4f8aee8c1b399dcbe105e10e096a9e2f21dc56b28a3c7aa42cf0a5023682" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.jobs" version="3.15.0">
<artifact name="org.eclipse.core.jobs-3.15.0.jar">
<sha256 value="857df690c6424a6558b5c96732958f03b9c209258562caf93d9fcbc13242fa11" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.jobs" version="3.15.300">
<artifact name="org.eclipse.core.jobs-3.15.300.jar">
<sha256 value="ad6db9d0e7d8579d01b750fdced6d6e1d410919047d4bfd3b7d6a65627e5063a" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.resources" version="3.19.100">
<artifact name="org.eclipse.core.resources-3.19.100.jar">
<sha256 value="537af88de2c0e602446ab0fa9dcfec29c617f0891b96fc4cc3fba1655edcc91b" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.resources" version="3.20.200">
<artifact name="org.eclipse.core.resources-3.20.200.jar">
<sha256 value="8b51dd0c72e54ecfd4b56a160769ca00a0d944ace10d47ef372fa4e103698b13" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.runtime" version="3.29.0">
<artifact name="org.eclipse.core.runtime-3.29.0.jar">
<sha256 value="096373dff05c425cb37e4924b25b3532a8f8c2992f36d4b6266b0e05a19af814" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.core.runtime" version="3.31.100">
<artifact name="org.eclipse.core.runtime-3.31.100.jar">
<sha256 value="aa484a9f9ecb6a2575d19d1a73bd943dbc9b2292751f4874109b7ac67fd904a8" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.app" version="1.6.300">
<artifact name="org.eclipse.equinox.app-1.6.300.jar">
<sha256 value="eaeb288c9bc78916027d3933d7d1f78c1b8675d54a55a7abdea161b001b7adf1" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.app" version="1.7.100">
<artifact name="org.eclipse.equinox.app-1.7.100.jar">
<sha256 value="7ebd054bc03da4d61abc166d22df41cfa0e49963a5b0c4b32dbe0b769b6c216d" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.common" version="3.18.100">
<artifact name="org.eclipse.equinox.common-3.18.100.jar">
<sha256 value="7c15db46dda5f6f1ff9ecac10eb6ffa9ed1cbd0ed5e6996cb95f0e390902700e" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.common" version="3.19.100">
<artifact name="org.eclipse.equinox.common-3.19.100.jar">
<sha256 value="77da20b3d040b9a00509add8583c659243a62e9f9633bc3f82b55e96b0a09427" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.event" version="1.6.200">
<artifact name="org.eclipse.equinox.event-1.6.200.jar">
<sha256 value="b83c7f7023a3c30daa75e112f3ad2c6d8c30108e19bbe84ec2d25b8bad0efe7a" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.event" version="1.7.100">
<artifact name="org.eclipse.equinox.event-1.7.100.jar">
<sha256 value="9f7dbc1ced29e627cb228ec205be7f4e496330eee450b31cb94c7973e4459561" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.preferences" version="3.10.300">
<artifact name="org.eclipse.equinox.preferences-3.10.300.jar">
<sha256 value="0e231ed4443b1bb21e16ec13a83e975bc04b0503eac2ce6f4b4a7d7b2f53956d" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.preferences" version="3.11.100">
<artifact name="org.eclipse.equinox.preferences-3.11.100.jar">
<sha256 value="2dece57392142293cd35b58132b7f6bb0ac599a35f2ce734fd2551440ec27b47" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.registry" version="3.11.300">
<artifact name="org.eclipse.equinox.registry-3.11.300.jar">
<sha256 value="3acbb9c857bae9093f3308aff5abe72be5eabcb23e2791139d3571cade659da0" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.registry" version="3.12.100">
<artifact name="org.eclipse.equinox.registry-3.12.100.jar">
<sha256 value="23ded56b950ae846e006870f836c29b8d545f3a7bf9ced28baf41b5a2e5e8dbb" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.supplement" version="1.10.700">
<artifact name="org.eclipse.equinox.supplement-1.10.700.jar">
<sha256 value="5df4309856c79492807c17f116ca112ea83c7dd04c2c01049f5d3b4811135068" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.equinox.supplement" version="1.10.900">
<artifact name="org.eclipse.equinox.supplement-1.10.900.jar">
<sha256 value="6edca163c9e251e8500765206b5728f91a929f664b692d6a5affb1ef644614ab" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.osgi" version="3.18.300">
<artifact name="org.eclipse.osgi-3.18.300.jar">
<sha256 value="bab943e58edd17309238672dba7a45aec9e2dacbdddb818a8cf17723ea13fa22" origin="Generated by Gradle"/>
@ -3618,11 +3738,21 @@
<sha256 value="80b275d58379723b291ea650249cc3809c8f10b34f78aaf988132cd6d434ab4e" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.osgi" version="3.20.0">
<artifact name="org.eclipse.osgi-3.20.0.jar">
<sha256 value="11e61736689f0c1af46c9a852420058e10c6072f936c8308b6eca50e46dd38ef" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.text" version="3.13.100">
<artifact name="org.eclipse.text-3.13.100.jar">
<sha256 value="89afa204e8e686eaa5f1464a6ceb65ac1b341ad1d0326cab6716c6733ecaf5ac" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.platform" name="org.eclipse.text" version="3.14.100">
<artifact name="org.eclipse.text-3.14.100.jar">
<sha256 value="7c9791768a715b1fef29dec8ba6a15a968bcc1cf7a766d439273fe52362eec65" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.eclipse.sisu" name="org.eclipse.sisu.inject" version="0.3.3">
<artifact name="org.eclipse.sisu.inject-0.3.3.jar">
<sha256 value="c6935e0b7d362ed4ca768c9b71d5d4d98788ff0a79c0d2bb954c221a078b166b" origin="Generated by Gradle"/>
@ -3653,6 +3783,11 @@
<sha256 value="17fdeb7e22375a7fb40bb0551306f6dcf2b5743078668adcdf6c642c9a9ec955" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.gradlex" name="build-parameters" version="1.4.4">
<artifact name="build-parameters-1.4.4.jar">
<sha256 value="54045988848801e84cffd604cfd94f6e2a613248d81ca315c20e74d0ac3b602c" origin="Generated by Gradle"/>
</artifact>
</component>
<component group="org.hamcrest" name="hamcrest" version="2.1">
<artifact name="hamcrest-2.1.jar">
<sha256 value="ba93b2e3a562322ba432f0a1b53addcc55cb188253319a020ed77f824e692050" origin="Generated by Gradle"/>

2
libs/simdvec/build.gradle
View file

@ -33,7 +33,7 @@ tasks.matching { it.name == "compileMain21Java" }.configureEach {
}
tasks.named('test').configure {
if (BuildParams.getRuntimeJavaVersion().majorVersion.toInteger() >= 21) {
if (buildParams.getRuntimeJavaVersion().map{ it.majorVersion.toInteger() }.get() >= 21) {
jvmArgs '--add-modules=jdk.incubator.vector'
}
}

2
modules/aggregations/build.gradle
View file

@ -28,7 +28,7 @@ restResources {
}
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

4
modules/data-streams/build.gradle
View file

@ -28,14 +28,14 @@ tasks.withType(StandaloneRestIntegTestTask).configureEach {
usesDefaultDistribution()
}
if (BuildParams.inFipsJvm){
if (buildParams.inFipsJvm){
// These fail in CI but only when run as part of checkPart2 and not individually.
// Tracked in :
tasks.named("javaRestTest").configure{enabled = false }
tasks.named("yamlRestTest").configure{enabled = false }
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.withType(Test).configureEach {
systemProperty 'es.failure_store_feature_flag_enabled', 'true'
}

2
modules/ingest-attachment/build.gradle
View file

@ -143,7 +143,7 @@ tasks.named("thirdPartyAudit").configure {
ignoreMissingClasses()
}
if (BuildParams.inFipsJvm) {
if (buildParams.inFipsJvm) {
tasks.named("test").configure { enabled = false }
tasks.named("yamlRestTest").configure { enabled = false };
tasks.named("yamlRestCompatTest").configure { enabled = false };

2
modules/ingest-geoip/qa/full-cluster-restart/build.gradle
View file

@ -24,7 +24,7 @@ dependencies {
// once we are ready to test migrations from 8.x to 9.x, we can set the compatible version to 8.0.0
// see https://github.com/elastic/elasticsearch/pull/93666
BuildParams.bwcVersions.withWireCompatible(v -> v.before("9.0.0")) { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible(v -> v.before("9.0.0")) { bwcVersion, baseName ->
tasks.register(bwcTaskName(bwcVersion), StandaloneRestIntegTestTask) {
usesBwcDistribution(bwcVersion)
systemProperty("tests.old_cluster_version", bwcVersion)

2
modules/legacy-geo/build.gradle
View file

@ -26,7 +26,7 @@ dependencies {
testImplementation project(":test:framework")
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

2
modules/mapper-extras/build.gradle
View file

@ -24,7 +24,7 @@ restResources {
}
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

2
modules/reindex/build.gradle
View file

@ -132,7 +132,7 @@ if (OS.current() == OS.WINDOWS) {
oldEsDependency.getAttributes().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, ArtifactTypeDefinition.DIRECTORY_TYPE);
TaskProvider<AntFixture> fixture = tasks.register("oldEs${version}Fixture", AntFixture) {
dependsOn project.configurations.oldesFixture, jdks.legacy, oldEsDependency
executable = "${BuildParams.runtimeJavaHome}/bin/java"
executable = "${buildParams.runtimeJavaHome.get()}/bin/java"
env 'CLASSPATH', "${-> project.configurations.oldesFixture.asPath}"
// old versions of Elasticsearch need JAVA_HOME
env 'JAVA_HOME', jdks.legacy.javaHomePath

2
modules/repository-azure/build.gradle
View file

@ -321,7 +321,7 @@ tasks.register("workloadIdentityYamlRestTest", RestIntegTestTask) {
// omitting key and sas_token so that we use a bearer token from workload identity
}
if (BuildParams.inFipsJvm) {
if (buildParams.inFipsJvm) {
// Cannot override the trust store in FIPS mode, and these tasks require a HTTPS fixture
tasks.named("managedIdentityYamlRestTest").configure { enabled = false }
tasks.named("workloadIdentityYamlRestTest").configure { enabled = false }

4
modules/repository-gcs/build.gradle
View file

@ -178,7 +178,7 @@ tasks.named("thirdPartyAudit").configure {
)
if(BuildParams.graalVmRuntime == false) {
if(buildParams.graalVmRuntime == false) {
ignoreMissingClasses(
'org.graalvm.nativeimage.hosted.Feature',
'org.graalvm.nativeimage.hosted.Feature$BeforeAnalysisAccess',
@ -240,7 +240,7 @@ def gcsThirdPartyTest = tasks.register("gcsThirdPartyUnitTest", Test) {
systemProperty 'tests.security.manager', false
systemProperty 'test.google.bucket', gcsBucket
systemProperty 'test.google.fixture', Boolean.toString(useFixture)
nonInputProperties.systemProperty 'test.google.base', gcsBasePath + "_third_party_tests_" + BuildParams.testSeed
nonInputProperties.systemProperty 'test.google.base', gcsBasePath + "_third_party_tests_" + buildParams.testSeed
if (useFixture == false) {
nonInputProperties.systemProperty 'test.google.account', "${-> encodedCredentials.call()}"
}

4
modules/repository-s3/build.gradle
View file

@ -115,7 +115,7 @@ String s3ECSBasePath = System.getenv("amazon_s3_base_path_ecs")
String s3STSBucket = System.getenv("amazon_s3_bucket_sts")
String s3STSBasePath = System.getenv("amazon_s3_base_path_sts")
boolean s3DisableChunkedEncoding = BuildParams.random.nextBoolean()
boolean s3DisableChunkedEncoding = buildParams.random.nextBoolean()
// If all these variables are missing then we are testing against the internal fixture instead, which has the following
// credentials hard-coded in.
@ -203,7 +203,7 @@ tasks.register("s3ThirdPartyTest", Test) {
systemProperty 'test.s3.account', s3PermanentAccessKey
systemProperty 'test.s3.key', s3PermanentSecretKey
systemProperty 'test.s3.bucket', s3PermanentBucket
nonInputProperties.systemProperty 'test.s3.base', s3PermanentBasePath + "_third_party_tests_" + BuildParams.testSeed
nonInputProperties.systemProperty 'test.s3.base', s3PermanentBasePath + "_third_party_tests_" + buildParams.testSeed
}
tasks.named("thirdPartyAudit").configure {

2
plugins/analysis-icu/build.gradle
View file

@ -28,7 +28,7 @@ dependencies {
api "com.ibm.icu:icu4j:${versions.icu4j}"
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

2
plugins/discovery-azure-classic/build.gradle
View file

@ -63,7 +63,7 @@ TaskProvider createKey = tasks.register("createKey", LoggedExec) {
keystore.parentFile.mkdirs()
}
outputs.file(keystore).withPropertyName('keystoreFile')
executable = "${BuildParams.runtimeJavaHome}/bin/keytool"
executable = "${buildParams.runtimeJavaHome.get()}/bin/keytool"
getStandardInput().set('FirstName LastName\nUnit\nOrganization\nCity\nState\nNL\nyes\n\n')
args '-genkey',
'-alias', 'test-node',

4
plugins/discovery-ec2/build.gradle
View file

@ -57,7 +57,7 @@ tasks.register("writeTestJavaPolicy") {
throw new GradleException("failed to create temporary directory [${tmp}]")
}
final File javaPolicy = file("${tmp}/java.policy")
if (BuildParams.inFipsJvm) {
if (buildParams.inFipsJvm) {
javaPolicy.write(
[
"grant {",
@ -98,7 +98,7 @@ tasks.named("test").configure {
// this is needed to manipulate com.amazonaws.sdk.ec2MetadataServiceEndpointOverride system property
// it is better rather disable security manager at all with `systemProperty 'tests.security.manager', 'false'`
if (BuildParams.inFipsJvm){
if (buildParams.inFipsJvm){
nonInputProperties.systemProperty 'java.security.policy', "=file://${buildDir}/tmp/java.policy"
} else {
nonInputProperties.systemProperty 'java.security.policy', "file://${buildDir}/tmp/java.policy"

2
plugins/discovery-ec2/qa/amazon-ec2/build.gradle
View file

@ -56,7 +56,7 @@ tasks.named("yamlRestTest").configure { enabled = false }
TaskProvider<AntFixture> fixture = tasks.register("ec2Fixture${action}", AntFixture) {
dependsOn project.sourceSets.yamlRestTest.runtimeClasspath
env 'CLASSPATH', "${-> project.sourceSets.yamlRestTest.runtimeClasspath.asPath}"
executable = "${BuildParams.runtimeJavaHome}/bin/java"
executable = "${buildParams.runtimeJavaHome.get()}/bin/java"
args 'org.elasticsearch.discovery.ec2.AmazonEC2Fixture', baseDir, "${buildDir}/testclusters/yamlRestTest${action}-1/config/unicast_hosts.txt"
}

2
plugins/discovery-gce/qa/gce/build.gradle
View file

@ -32,7 +32,7 @@ restResources {
def gceFixtureProvider = tasks.register("gceFixture", AntFixture) {
dependsOn project.sourceSets.yamlRestTest.runtimeClasspath
env 'CLASSPATH', "${-> project.sourceSets.yamlRestTest.runtimeClasspath.asPath}"
executable = "${BuildParams.runtimeJavaHome}/bin/java"
executable = "${buildParams.runtimeJavaHome.get()}/bin/java"
args 'org.elasticsearch.cloud.gce.GCEFixture', baseDir, "${buildDir}/testclusters/yamlRestTest-1/config/unicast_hosts.txt"
}

2
plugins/mapper-annotated-text/build.gradle
View file

@ -16,7 +16,7 @@ esplugin {
classname 'org.elasticsearch.index.mapper.annotatedtext.AnnotatedTextPlugin'
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

2
plugins/mapper-murmur3/build.gradle
View file

@ -22,7 +22,7 @@ dependencies {
testImplementation project(':modules:lang-painless')
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

2
plugins/repository-hdfs/build.gradle
View file

@ -84,7 +84,7 @@ tasks.named("dependencyLicenses").configure {
tasks.withType(RestIntegTestTask).configureEach {
usesDefaultDistribution()
BuildParams.withFipsEnabledOnly(it)
buildParams.withFipsEnabledOnly(it)
jvmArgs '--add-exports', 'java.security.jgss/sun.security.krb5=ALL-UNNAMED'
}

4
qa/ccs-rolling-upgrade-remote-cluster/build.gradle
View file

@ -16,7 +16,7 @@ apply plugin: 'elasticsearch.standalone-rest-test'
apply plugin: 'elasticsearch.bwc-test'
apply plugin: 'elasticsearch.rest-resources'
BuildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
/**
* We execute tests 3 times.
@ -52,7 +52,7 @@ BuildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
nonInputProperties.systemProperty('tests.rest.remote_cluster', remoteCluster.map(c -> c.allHttpSocketURI.join(",")))
}
onlyIf("FIPS mode disabled") { BuildParams.inFipsJvm == false }
onlyIf("FIPS mode disabled") { buildParams.inFipsJvm == false }
}
tasks.register("${baseName}#oldClusterTest", StandaloneRestIntegTestTask) {

3
qa/full-cluster-restart/build.gradle
View file

@ -7,14 +7,13 @@
* License v3.0 only", or the "Server Side Public License, v 1".
*/
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.testclusters.StandaloneRestIntegTestTask
apply plugin: 'elasticsearch.internal-java-rest-test'
apply plugin: 'elasticsearch.internal-test-artifact'
apply plugin: 'elasticsearch.bwc-test'
BuildParams.bwcVersions.withIndexCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withIndexCompatible { bwcVersion, baseName ->
tasks.register(bwcTaskName(bwcVersion), StandaloneRestIntegTestTask) {
usesBwcDistribution(bwcVersion)
systemProperty("tests.old_cluster_version", bwcVersion)

4
qa/mixed-cluster/build.gradle
View file

@ -10,7 +10,6 @@
import org.elasticsearch.gradle.Version
import org.elasticsearch.gradle.VersionProperties
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.testclusters.StandaloneRestIntegTestTask
apply plugin: 'elasticsearch.internal-testclusters'
@ -64,8 +63,7 @@ excludeList.add('indices.resolve_index/20_resolve_system_index/*')
// Excluded because the error has changed
excludeList.add('aggregations/percentiles_hdr_metric/Negative values test')
BuildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
if (bwcVersion != VersionProperties.getElasticsearchVersion()) {
/* This project runs the core REST tests against a 4 node cluster where two of
the nodes has a different minor. */

2
qa/multi-cluster-search/build.gradle
View file

@ -35,7 +35,7 @@ def ccsSupportedVersion = bwcVersion -> {
return currentVersion.minor == 0 || (currentVersion.major == bwcVersion.major && currentVersion.minor - bwcVersion.minor <= 1)
}
BuildParams.bwcVersions.withWireCompatible(ccsSupportedVersion) { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible(ccsSupportedVersion) { bwcVersion, baseName ->
def remoteCluster = testClusters.register("${baseName}-remote") {
numberOfNodes = 2

2
qa/repository-multi-version/build.gradle
View file

@ -16,7 +16,7 @@ apply plugin: 'elasticsearch.internal-test-artifact'
apply plugin: 'elasticsearch.bwc-test'
BuildParams.bwcVersions.withIndexCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withIndexCompatible { bwcVersion, baseName ->
String oldClusterName = "${baseName}-old"
String newClusterName = "${baseName}-new"

3
qa/rolling-upgrade-legacy/build.gradle
View file

@ -10,7 +10,6 @@
import org.elasticsearch.gradle.Version
import org.elasticsearch.gradle.internal.info.BuildParams
import org.elasticsearch.gradle.testclusters.StandaloneRestIntegTestTask
apply plugin: 'elasticsearch.internal-testclusters'
@ -18,7 +17,7 @@ apply plugin: 'elasticsearch.standalone-rest-test'
apply plugin: 'elasticsearch.bwc-test'
apply plugin: 'elasticsearch.rest-resources'
BuildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
/*
* NOTE: This module is for the tests that were problematic when converting :qa:rolling-upgrade to the junit-based bwc test definition
* Over time, these should be migrated into the :qa:rolling-upgrade module and fixed properly

2
qa/rolling-upgrade/build.gradle
View file

@ -18,7 +18,7 @@ testArtifacts {
registerTestArtifactFromSourceSet(sourceSets.javaRestTest)
}
BuildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible { bwcVersion, baseName ->
tasks.register(bwcTaskName(bwcVersion), StandaloneRestIntegTestTask) {
usesBwcDistribution(bwcVersion)
systemProperty("tests.old_cluster_version", bwcVersion)

1
qa/smoke-test-plugins/build.gradle
View file

@ -8,7 +8,6 @@
*/
import org.apache.tools.ant.filters.ReplaceTokens
import org.elasticsearch.gradle.internal.info.BuildParams
apply plugin: 'elasticsearch.legacy-yaml-rest-test'

2
qa/verify-version-constants/build.gradle
View file

@ -19,7 +19,7 @@ dependencies {
testImplementation project(':modules:rest-root')
}
BuildParams.bwcVersions.withIndexCompatible { bwcVersion, baseName ->
buildParams.bwcVersions.withIndexCompatible { bwcVersion, baseName ->
def baseCluster = testClusters.register(baseName) {
version = bwcVersion.toString()
setting 'xpack.security.enabled', 'true'

2
server/build.gradle
View file

@ -133,7 +133,7 @@ def generatePluginsList = tasks.register("generatePluginsList") {
sourceSets.main.output.dir(generatedResourcesDir)
sourceSets.main.compiledBy(generateModulesList, generatePluginsList)
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
systemProperty 'es.failure_store_feature_flag_enabled', 'true'

86
server/src/test/java/org/elasticsearch/repositories/RepositoriesModuleTests.java
View file

@ -65,14 +65,26 @@ public class RepositoriesModuleTests extends ESTestCase {
}
public void testCanRegisterTwoRepositoriesWithDifferentTypes() {
when(plugin1.getRepositories(eq(environment), eq(contentRegistry), eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE), eq(recoverySettings),
any(RepositoriesMetrics.class)))
.thenReturn(Collections.singletonMap("type1", factory));
when(plugin2.getRepositories(eq(environment), eq(contentRegistry), eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE), eq(recoverySettings),
any(RepositoriesMetrics.class)))
.thenReturn(Collections.singletonMap("type2", factory));
when(
plugin1.getRepositories(
eq(environment),
eq(contentRegistry),
eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE),
eq(recoverySettings),
any(RepositoriesMetrics.class)
)
).thenReturn(Collections.singletonMap("type1", factory));
when(
plugin2.getRepositories(
eq(environment),
eq(contentRegistry),
eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE),
eq(recoverySettings),
any(RepositoriesMetrics.class)
)
).thenReturn(Collections.singletonMap("type2", factory));
// Would throw
new RepositoriesModule(
@ -83,18 +95,32 @@ public class RepositoriesModuleTests extends ESTestCase {
mock(ClusterService.class),
MockBigArrays.NON_RECYCLING_INSTANCE,
contentRegistry,
recoverySettings, TelemetryProvider.NOOP);
recoverySettings,
TelemetryProvider.NOOP
);
}
public void testCannotRegisterTwoRepositoriesWithSameTypes() {
when(plugin1.getRepositories(eq(environment), eq(contentRegistry), eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE), eq(recoverySettings),
any(RepositoriesMetrics.class)))
.thenReturn(Collections.singletonMap("type1", factory));
when(plugin2.getRepositories(eq(environment), eq(contentRegistry), eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE), eq(recoverySettings),
any(RepositoriesMetrics.class)))
.thenReturn(Collections.singletonMap("type1", factory));
when(
plugin1.getRepositories(
eq(environment),
eq(contentRegistry),
eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE),
eq(recoverySettings),
any(RepositoriesMetrics.class)
)
).thenReturn(Collections.singletonMap("type1", factory));
when(
plugin2.getRepositories(
eq(environment),
eq(contentRegistry),
eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE),
eq(recoverySettings),
any(RepositoriesMetrics.class)
)
).thenReturn(Collections.singletonMap("type1", factory));
IllegalArgumentException ex = expectThrows(
IllegalArgumentException.class,
@ -106,7 +132,9 @@ public class RepositoriesModuleTests extends ESTestCase {
clusterService,
MockBigArrays.NON_RECYCLING_INSTANCE,
contentRegistry,
recoverySettings, TelemetryProvider.NOOP)
recoverySettings,
TelemetryProvider.NOOP
)
);
assertEquals("Repository type [type1] is already registered", ex.getMessage());
@ -130,17 +158,25 @@ public class RepositoriesModuleTests extends ESTestCase {
clusterService,
MockBigArrays.NON_RECYCLING_INSTANCE,
contentRegistry,
recoverySettings, TelemetryProvider.NOOP)
recoverySettings,
TelemetryProvider.NOOP
)
);
assertEquals("Internal repository type [type1] is already registered", ex.getMessage());
}
public void testCannotRegisterNormalAndInternalRepositoriesWithSameTypes() {
when(plugin1.getRepositories(eq(environment), eq(contentRegistry), eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE), eq(recoverySettings),
any(RepositoriesMetrics.class)))
.thenReturn(Collections.singletonMap("type1", factory));
when(
plugin1.getRepositories(
eq(environment),
eq(contentRegistry),
eq(clusterService),
eq(MockBigArrays.NON_RECYCLING_INSTANCE),
eq(recoverySettings),
any(RepositoriesMetrics.class)
)
).thenReturn(Collections.singletonMap("type1", factory));
when(plugin2.getInternalRepositories(environment, contentRegistry, clusterService, recoverySettings)).thenReturn(
Collections.singletonMap("type1", factory)
);
@ -155,7 +191,9 @@ public class RepositoriesModuleTests extends ESTestCase {
clusterService,
MockBigArrays.NON_RECYCLING_INSTANCE,
contentRegistry,
recoverySettings, TelemetryProvider.NOOP)
recoverySettings,
TelemetryProvider.NOOP
)
);
assertEquals("Internal repository type [type1] is already registered as a non-internal repository", ex.getMessage());

2
test/external-modules/apm-integration/build.gradle
View file

@ -17,7 +17,7 @@ tasks.named("test").configure {
}
tasks.named('javaRestTest').configure {
it.onlyIf("snapshot build") { BuildParams.isSnapshotBuild() }
it.onlyIf("snapshot build") { buildParams.isSnapshotBuild() }
}
dependencies {

2
test/external-modules/delayed-aggs/build.gradle
View file

@ -11,7 +11,7 @@ import org.elasticsearch.gradle.internal.info.BuildParams
apply plugin: 'elasticsearch.legacy-yaml-rest-test'
tasks.named('yamlRestTest').configure {
it.onlyIf("snapshot build") { BuildParams.isSnapshotBuild() }
it.onlyIf("snapshot build") { buildParams.isSnapshotBuild() }
}
esplugin {

2
test/external-modules/die-with-dignity/build.gradle
View file

@ -17,5 +17,5 @@ tasks.named("test").configure {
}
tasks.named('javaRestTest').configure {
it.onlyIf("snapshot build") { BuildParams.isSnapshotBuild() }
it.onlyIf("snapshot build") { buildParams.isSnapshotBuild() }
}

2
test/external-modules/error-query/build.gradle
View file

@ -11,7 +11,7 @@ import org.elasticsearch.gradle.internal.info.BuildParams
apply plugin: 'elasticsearch.legacy-yaml-rest-test'
tasks.named('yamlRestTest').configure {
it.onlyIf("snapshot build") { BuildParams.isSnapshotBuild() }
it.onlyIf("snapshot build") { buildParams.isSnapshotBuild() }
}
esplugin {

2
test/external-modules/esql-heap-attack/build.gradle
View file

@ -21,5 +21,5 @@ esplugin {
tasks.named('javaRestTest') {
usesDefaultDistribution()
it.onlyIf("snapshot build") { BuildParams.isSnapshotBuild() }
it.onlyIf("snapshot build") { buildParams.isSnapshotBuild() }
}

2
test/external-modules/jvm-crash/build.gradle
View file

@ -21,5 +21,5 @@ esplugin {
tasks.named('javaRestTest') {
usesDefaultDistribution()
it.onlyIf("snapshot build") { BuildParams.isSnapshotBuild() }
it.onlyIf("snapshot build") { buildParams.isSnapshotBuild() }
}

6
test/framework/build.gradle
View file

@ -85,9 +85,9 @@ tasks.named("thirdPartyAudit").configure {
}
tasks.named("test").configure {
systemProperty 'tests.gradle_index_compat_versions', BuildParams.bwcVersions.indexCompatible.join(',')
systemProperty 'tests.gradle_wire_compat_versions', BuildParams.bwcVersions.wireCompatible.join(',')
systemProperty 'tests.gradle_unreleased_versions', BuildParams.bwcVersions.unreleased.join(',')
systemProperty 'tests.gradle_index_compat_versions', buildParams.bwcVersions.indexCompatible.join(',')
systemProperty 'tests.gradle_wire_compat_versions', buildParams.bwcVersions.wireCompatible.join(',')
systemProperty 'tests.gradle_unreleased_versions', buildParams.bwcVersions.unreleased.join(',')
}
tasks.register("integTest", Test) {

8
test/immutable-collections-patch/build.gradle
View file

@ -26,14 +26,14 @@ def outputDir = layout.buildDirectory.dir("jdk-patches")
def generatePatch = tasks.register("generatePatch", JavaExec)
generatePatch.configure {
dependsOn tasks.named("compileJava")
inputs.property("java-home-set", BuildParams.getIsRuntimeJavaHomeSet())
inputs.property("java-version", BuildParams.runtimeJavaVersion)
inputs.property("java-home-set", buildParams.getIsRuntimeJavaHomeSet())
inputs.property("java-version", buildParams.runtimeJavaVersion)
outputs.dir(outputDir)
classpath = sourceSets.main.runtimeClasspath
mainClass = 'org.elasticsearch.jdk.patch.ImmutableCollectionsPatcher'
if (BuildParams.getIsRuntimeJavaHomeSet()) {
executable = "${BuildParams.runtimeJavaHome}/bin/java" + (OS.current() == OS.WINDOWS ? '.exe' : '')
if (buildParams.getIsRuntimeJavaHomeSet()) {
executable = "${buildParams.runtimeJavaHome.get()}/bin/java" + (OS.current() == OS.WINDOWS ? '.exe' : '')
} else {
javaLauncher = javaToolchains.launcherFor {
languageVersion = JavaLanguageVersion.of(VersionProperties.bundledJdkMajorVersion)

2
x-pack/plugin/analytics/build.gradle
View file

@ -21,7 +21,7 @@ dependencies {
testImplementation(testArtifact(project(xpackModule('core'))))
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.named("test").configure {
systemProperty 'es.index_mode_feature_flag_registered', 'true'
}

2
x-pack/plugin/async-search/qa/rest/build.gradle
View file

@ -28,5 +28,5 @@ testClusters.configureEach {
// Test clusters run with security disabled
tasks.named("yamlRestTest") {
BuildParams.withFipsEnabledOnly(it)
buildParams.withFipsEnabledOnly(it)
}

2
x-pack/plugin/build.gradle
View file

@ -37,7 +37,7 @@ artifacts {
def restTestBlacklist = []
// TODO: fix this rest test to not depend on a hardcoded port!
restTestBlacklist.addAll(['getting_started/10_monitor_cluster_health/*'])
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
// these tests attempt to install basic/internal licenses signed against the dev/public.key
// Since there is no infrastructure in place (anytime soon) to generate licenses using the production
// private key, these tests are blacklisted in non-snapshot test runs

2
x-pack/plugin/ccr/qa/build.gradle
View file

@ -10,6 +10,6 @@ subprojects {
tasks.withType(Test).configureEach {
// These fail in CI but only when run as part of checkPart2 and not individually.
// Tracked in : https://github.com/elastic/elasticsearch/issues/66661
BuildParams.withFipsEnabledOnly(it)
buildParams.withFipsEnabledOnly(it)
}
}

6
x-pack/plugin/core/build.gradle
View file

@ -94,7 +94,7 @@ tasks.named("processResources").configure {
String licenseKey = providers.systemProperty("license.key").getOrNull()
if (licenseKey != null) {
println "Using provided license key from ${licenseKey}"
} else if (BuildParams.isSnapshotBuild()) {
} else if (buildParams.isSnapshotBuild()) {
licenseKey = Paths.get(project.projectDir.path, 'snapshot.key')
} else {
throw new IllegalArgumentException('Property license.key must be set for release build')
@ -155,13 +155,13 @@ testClusters.configureEach {
requiresFeature 'es.failure_store_feature_flag_enabled', Version.fromString("8.15.0")
}
if (BuildParams.isSnapshotBuild() == false) {
if (buildParams.isSnapshotBuild() == false) {
tasks.withType(Test).configureEach {
systemProperty 'es.failure_store_feature_flag_enabled', 'true'
}
}
if (BuildParams.inFipsJvm) {
if (buildParams.inFipsJvm) {
// Test clusters run with security disabled
tasks.named("javaRestTest").configure { enabled = false }
}

2
x-pack/plugin/deprecation/qa/early-deprecation-rest/build.gradle
View file

@ -37,6 +37,6 @@ testClusters.configureEach {
// Test clusters run with security disabled
tasks.named("javaRestTest") {
BuildParams.withFipsEnabledOnly(it)
buildParams.withFipsEnabledOnly(it)
}

2
x-pack/plugin/deprecation/qa/rest/build.gradle
View file

@ -34,5 +34,5 @@ testClusters.configureEach {
// Test clusters run with security disabled
tasks.named("javaRestTest") {
BuildParams.withFipsEnabledOnly(it)
buildParams.withFipsEnabledOnly(it)
}

2
x-pack/plugin/downsample/qa/mixed-cluster/build.gradle
View file

@ -29,7 +29,7 @@ def supportedVersion = bwcVersion -> {
return bwcVersion.onOrAfter("8.10.0") && bwcVersion != VersionProperties.elasticsearchVersion
}
BuildParams.bwcVersions.withWireCompatible(supportedVersion) { bwcVersion, baseName ->
buildParams.bwcVersions.withWireCompatible(supportedVersion) { bwcVersion, baseName ->
def yamlRestTest = tasks.register("v${bwcVersion}#yamlRestTest", StandaloneRestIntegTestTask) {
usesDefaultDistribution()

2
x-pack/plugin/downsample/qa/rest/build.gradle
View file

@ -32,7 +32,7 @@ tasks.named('yamlRestTest') {
tasks.named('yamlRestCompatTest') {
usesDefaultDistribution()
}
if (BuildParams.inFipsJvm){
if (buildParams.inFipsJvm){
// This test cluster is using a BASIC license and FIPS 140 mode is not supported in BASIC
tasks.named("yamlRestTest").configure{enabled = false }
}

2
x-pack/plugin/downsample/qa/with-security/build.gradle
View file

@ -28,7 +28,7 @@ testClusters.configureEach {
user username: 'elastic_admin', password: 'admin-password'
}
if (BuildParams.inFipsJvm){
if (buildParams.inFipsJvm){
// This test cluster is using a BASIC license and FIPS 140 mode is not supported in BASIC
tasks.named("yamlRestTest").configure{enabled = false }
}

Some files were not shown because too many files have changed in this diff Show more