forked from elastic/elasticsearch
/
InternalDistributionBwcSetupPlugin.java
329 lines (293 loc) · 15.2 KB
/
InternalDistributionBwcSetupPlugin.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
/*
* 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 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 or the Server
* Side Public License, v 1.
*/
package org.elasticsearch.gradle.internal;
import org.elasticsearch.gradle.Version;
import org.elasticsearch.gradle.internal.info.BuildParams;
import org.elasticsearch.gradle.internal.info.GlobalBuildInfoPlugin;
import org.gradle.api.Action;
import org.gradle.api.InvalidUserDataException;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.api.services.BuildService;
import org.gradle.api.services.BuildServiceParameters;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.language.base.plugins.LifecycleBasePlugin;
import java.io.File;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;
import javax.inject.Inject;
import static java.util.Arrays.asList;
import static java.util.Arrays.stream;
/**
* We want to be able to do BWC tests for unreleased versions without relying on and waiting for snapshots.
* For this we need to check out and build the unreleased versions.
* Since these depend on the current version, we can't name the Gradle projects statically, and don't know what the
* unreleased versions are when Gradle projects are set up, so we use "build-unreleased-version-*" as placeholders
* and configure them to build various versions here.
*/
public class InternalDistributionBwcSetupPlugin implements Plugin<Project> {
private static final String BWC_TASK_THROTTLE_SERVICE = "bwcTaskThrottle";
private ProviderFactory providerFactory;
@Inject
public InternalDistributionBwcSetupPlugin(ProviderFactory providerFactory) {
this.providerFactory = providerFactory;
}
@Override
public void apply(Project project) {
project.getRootProject().getPluginManager().apply(GlobalBuildInfoPlugin.class);
Provider<BwcTaskThrottle> bwcTaskThrottleProvider = project.getGradle()
.getSharedServices()
.registerIfAbsent(BWC_TASK_THROTTLE_SERVICE, BwcTaskThrottle.class, spec -> spec.getMaxParallelUsages().set(1));
BuildParams.getBwcVersions()
.forPreviousUnreleased(
(BwcVersions.UnreleasedVersionInfo unreleasedVersion) -> {
configureBwcProject(project.project(unreleasedVersion.gradleProjectPath), unreleasedVersion, bwcTaskThrottleProvider);
}
);
}
private void configureBwcProject(
Project project,
BwcVersions.UnreleasedVersionInfo versionInfo,
Provider<BwcTaskThrottle> bwcTaskThrottleProvider
) {
Provider<BwcVersions.UnreleasedVersionInfo> versionInfoProvider = providerFactory.provider(() -> versionInfo);
Provider<File> checkoutDir = versionInfoProvider.map(info -> new File(project.getBuildDir(), "bwc/checkout-" + info.branch));
BwcSetupExtension bwcSetupExtension = project.getExtensions()
.create("bwcSetup", BwcSetupExtension.class, project, versionInfoProvider, bwcTaskThrottleProvider, checkoutDir);
BwcGitExtension gitExtension = project.getPlugins().apply(InternalBwcGitPlugin.class).getGitExtension();
Provider<Version> bwcVersion = versionInfoProvider.map(info -> info.version);
gitExtension.setBwcVersion(versionInfoProvider.map(info -> info.version));
gitExtension.setBwcBranch(versionInfoProvider.map(info -> info.branch));
gitExtension.getCheckoutDir().set(checkoutDir);
// we want basic lifecycle tasks like `clean` here.
project.getPlugins().apply(LifecycleBasePlugin.class);
TaskProvider<Task> buildBwcTaskProvider = project.getTasks().register("buildBwc");
List<DistributionProject> distributionProjects = resolveArchiveProjects(checkoutDir.get(), bwcVersion.get());
for (DistributionProject distributionProject : distributionProjects) {
createBuildBwcTask(
bwcSetupExtension,
project,
bwcVersion,
distributionProject.name,
distributionProject.projectPath,
distributionProject.expectedBuildArtifact,
buildBwcTaskProvider,
distributionProject.getAssembleTaskName()
);
registerBwcDistributionArtifacts(project, distributionProject);
}
// Create build tasks for the JDBC driver used for compatibility testing
String jdbcProjectDir = "x-pack/plugin/sql/jdbc";
DistributionProjectArtifact jdbcProjectArtifact = new DistributionProjectArtifact(
new File(checkoutDir.get(), jdbcProjectDir + "/build/distributions/x-pack-sql-jdbc-" + bwcVersion.get() + "-SNAPSHOT.jar"),
null
);
createBuildBwcTask(
bwcSetupExtension,
project,
bwcVersion,
"jdbc",
jdbcProjectDir,
jdbcProjectArtifact,
buildBwcTaskProvider,
"assemble"
);
}
private void registerBwcDistributionArtifacts(Project bwcProject, DistributionProject distributionProject) {
String projectName = distributionProject.name;
String buildBwcTask = buildBwcTaskName(projectName);
registerDistributionArchiveArtifact(bwcProject, distributionProject, buildBwcTask);
File expectedExpandedDistDirectory = distributionProject.expectedBuildArtifact.expandedDistDir;
if (expectedExpandedDistDirectory != null) {
String expandedDistConfiguration = "expanded-" + projectName;
bwcProject.getConfigurations().create(expandedDistConfiguration);
bwcProject.getArtifacts().add(expandedDistConfiguration, expectedExpandedDistDirectory, artifact -> {
artifact.setName("elasticsearch");
artifact.builtBy(buildBwcTask);
artifact.setType("directory");
});
}
}
private void registerDistributionArchiveArtifact(Project bwcProject, DistributionProject distributionProject, String buildBwcTask) {
File distFile = distributionProject.expectedBuildArtifact.distFile;
String artifactFileName = distFile.getName();
String artifactName = artifactFileName.contains("oss") ? "elasticsearch-oss" : "elasticsearch";
String suffix = artifactFileName.endsWith("tar.gz") ? "tar.gz" : artifactFileName.substring(artifactFileName.length() - 3);
int x86ArchIndex = artifactFileName.indexOf("x86_64");
int aarch64ArchIndex = artifactFileName.indexOf("aarch64");
bwcProject.getConfigurations().create(distributionProject.name);
bwcProject.getArtifacts().add(distributionProject.name, distFile, artifact -> {
artifact.setName(artifactName);
artifact.builtBy(buildBwcTask);
artifact.setType(suffix);
String classifier = "";
if (x86ArchIndex != -1) {
int osIndex = artifactFileName.lastIndexOf('-', x86ArchIndex - 2);
classifier = "-" + artifactFileName.substring(osIndex + 1, x86ArchIndex - 1) + "-x86_64";
} else if (aarch64ArchIndex != -1) {
int osIndex = artifactFileName.lastIndexOf('-', aarch64ArchIndex - 2);
classifier = "-" + artifactFileName.substring(osIndex + 1, aarch64ArchIndex - 1) + "-aarch64";
}
artifact.setClassifier(classifier);
});
}
private static List<DistributionProject> resolveArchiveProjects(File checkoutDir, Version bwcVersion) {
List<String> projects = new ArrayList<>();
if (bwcVersion.onOrAfter("7.13.0")) {
projects.addAll(asList("deb", "rpm"));
projects.addAll(asList("windows-zip", "darwin-tar", "linux-tar"));
projects.addAll(asList("darwin-aarch64-tar", "linux-aarch64-tar"));
} else {
projects.addAll(asList("deb", "rpm", "oss-deb", "oss-rpm"));
if (bwcVersion.onOrAfter("7.0.0")) { // starting with 7.0 we bundle a jdk which means we have platform-specific archives
projects.addAll(asList("oss-windows-zip", "windows-zip", "oss-darwin-tar", "darwin-tar", "oss-linux-tar", "linux-tar"));
// We support aarch64 for linux and mac starting from 7.12
if (bwcVersion.onOrAfter("7.12.0")) {
projects.addAll(asList("oss-darwin-aarch64-tar", "oss-linux-aarch64-tar", "darwin-aarch64-tar", "linux-aarch64-tar"));
}
} else { // prior to 7.0 we published only a single zip and tar archives for oss and default distributions
projects.addAll(asList("oss-zip", "zip", "tar", "oss-tar"));
}
}
return projects.stream().map(name -> {
String baseDir = "distribution" + (name.endsWith("zip") || name.endsWith("tar") ? "/archives" : "/packages");
String classifier = "";
String extension = name;
if (bwcVersion.onOrAfter("7.0.0")) {
if (name.contains("zip") || name.contains("tar")) {
int index = name.lastIndexOf('-');
String baseName = name.startsWith("oss-") ? name.substring(4, index) : name.substring(0, index);
classifier = "-" + baseName + (name.contains("aarch64") ? "-aarch64" : "-x86_64");
extension = name.substring(index + 1);
if (extension.equals("tar")) {
extension += ".gz";
}
} else if (name.contains("deb")) {
classifier = "-amd64";
} else if (name.contains("rpm")) {
classifier = "-x86_64";
}
} else if (name.contains("oss-")) {
extension = name.substring(4);
}
return new DistributionProject(name, baseDir, bwcVersion, classifier, extension, checkoutDir);
}).collect(Collectors.toList());
}
private static String buildBwcTaskName(String projectName) {
return "buildBwc"
+ stream(projectName.split("-")).map(i -> i.substring(0, 1).toUpperCase(Locale.ROOT) + i.substring(1))
.collect(Collectors.joining());
}
static void createBuildBwcTask(
BwcSetupExtension bwcSetupExtension,
Project project,
Provider<Version> bwcVersion,
String projectName,
String projectPath,
DistributionProjectArtifact projectArtifact,
TaskProvider<Task> bwcTaskProvider,
String assembleTaskName
) {
String bwcTaskName = buildBwcTaskName(projectName);
bwcSetupExtension.bwcTask(bwcTaskName, c -> {
boolean useNativeExpanded = projectArtifact.expandedDistDir != null;
File expectedOutputFile = useNativeExpanded
? new File(projectArtifact.expandedDistDir, "elasticsearch-" + bwcVersion.get() + "-SNAPSHOT")
: projectArtifact.distFile;
c.getInputs().file(new File(project.getBuildDir(), "refspec"));
if (useNativeExpanded) {
c.getOutputs().dir(expectedOutputFile);
} else {
c.getOutputs().files(expectedOutputFile);
}
c.getOutputs().cacheIf("BWC distribution caching is disabled on 'main' branch", task -> {
String gitBranch = System.getenv("GIT_BRANCH");
return BuildParams.isCi()
&& (gitBranch == null || gitBranch.endsWith("master") == false || gitBranch.endsWith("main") == false);
});
c.args(projectPath.replace('/', ':') + ":" + assembleTaskName);
if (project.getGradle().getStartParameter().isBuildCacheEnabled()) {
c.args("--build-cache");
}
c.doLast(new Action<Task>() {
@Override
public void execute(Task task) {
if (expectedOutputFile.exists() == false) {
Path relativeOutputPath = project.getRootDir().toPath().relativize(expectedOutputFile.toPath());
final String message = "Building %s didn't generate expected artifact [%s]. The working branch may be "
+ "out-of-date - try merging in the latest upstream changes to the branch.";
throw new InvalidUserDataException(message.formatted(bwcVersion.get(), relativeOutputPath));
}
}
});
});
bwcTaskProvider.configure(t -> t.dependsOn(bwcTaskName));
}
/**
* Represents an archive project (distribution/archives/*)
* we build from a bwc Version in a cloned repository
*/
private static class DistributionProject {
final String name;
final File checkoutDir;
final String projectPath;
/**
* can be removed once we don't build 7.10 anymore
* from source for bwc tests.
*/
@Deprecated
final boolean expandedDistDirSupport;
final DistributionProjectArtifact expectedBuildArtifact;
private final boolean extractedAssembleSupported;
DistributionProject(String name, String baseDir, Version version, String classifier, String extension, File checkoutDir) {
this.name = name;
this.checkoutDir = checkoutDir;
this.projectPath = baseDir + "/" + name;
this.expandedDistDirSupport = version.onOrAfter("7.10.0") && (name.endsWith("zip") || name.endsWith("tar"));
this.extractedAssembleSupported = version.onOrAfter("7.11.0") && (name.endsWith("zip") || name.endsWith("tar"));
this.expectedBuildArtifact = new DistributionProjectArtifact(
new File(
checkoutDir,
baseDir
+ "/"
+ name
+ "/build/distributions/elasticsearch-"
+ (name.startsWith("oss") ? "oss-" : "")
+ version
+ "-SNAPSHOT"
+ classifier
+ "."
+ extension
),
expandedDistDirSupport ? new File(checkoutDir, baseDir + "/" + name + "/build/install") : null
);
}
/**
* Newer elasticsearch branches allow building extracted bwc elasticsearch versions
* from source without the overhead of creating an archive by using assembleExtracted instead of assemble.
*/
public String getAssembleTaskName() {
return extractedAssembleSupported ? "extractedAssemble" : "assemble";
}
}
private static class DistributionProjectArtifact {
final File distFile;
final File expandedDistDir;
DistributionProjectArtifact(File distFile, File expandedDistDir) {
this.distFile = distFile;
this.expandedDistDir = expandedDistDir;
}
}
public abstract class BwcTaskThrottle implements BuildService<BuildServiceParameters.None> {}
}