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

8
TESTING.asciidoc
View file

@ -472,7 +472,7 @@ You can run a group of YAML test by using wildcards:
--tests "org.elasticsearch.test.rest.ClientYamlTestSuiteIT.test {yaml=index/*/*}"
---------------------------------------------------------------------------
or
or
---------------------------------------------------------------------------
./gradlew :rest-api-spec:yamlRestTest \
@ -564,8 +564,8 @@ Sometimes a backward compatibility change spans two versions.
A common case is a new functionality that needs a BWC bridge in an unreleased versioned of a release branch (for example, 5.x).
Another use case, since the introduction of serverless, is to test BWC against main in addition to the other released branches.
To do so, specify the `bwc.refspec` remote and branch to use for the BWC build as `origin/main`.
To test against main, you will also need to create a new version in link:./server/src/main/java/org/elasticsearch/Version.java[Version.java],
increment `elasticsearch` in link:./build-tools-internal/version.properties[version.properties], and hard-code the `project.version` for ml-cpp
To test against main, you will also need to create a new version in link:./server/src/main/java/org/elasticsearch/Version.java[Version.java],
increment `elasticsearch` in link:./build-tools-internal/version.properties[version.properties], and hard-code the `project.version` for ml-cpp
in link:./x-pack/plugin/ml/build.gradle[ml/build.gradle].
In general, to test the changes, you can instruct Gradle to build the BWC version from another remote/branch combination instead of pulling the release branch from GitHub.
@ -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