230 lines
8.1 KiB
Groovy
230 lines
8.1 KiB
Groovy
/*
|
|
* Licensed to Elasticsearch under one or more contributor
|
|
* license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright
|
|
* ownership. Elasticsearch licenses this file to you under
|
|
* the Apache License, Version 2.0 (the "License"); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
|
|
|
|
import org.apache.tools.ant.taskdefs.condition.Os
|
|
import org.elasticsearch.gradle.LoggedExec
|
|
import org.elasticsearch.gradle.Version
|
|
|
|
import java.nio.charset.StandardCharsets
|
|
|
|
import static org.elasticsearch.gradle.BuildPlugin.getJavaHome
|
|
/**
|
|
* This is a dummy project which does a local checkout of the previous
|
|
* wire compat version's branch, and builds a snapshot. This allows backcompat
|
|
* tests to test against the next unreleased version, closest to this version,
|
|
* without relying on snapshots.
|
|
*/
|
|
subprojects {
|
|
|
|
Version bwcVersion = bwcVersions.getSnapshotForProject(project.name)
|
|
if (bwcVersion == null) {
|
|
// this project wont do anything
|
|
return
|
|
}
|
|
|
|
String bwcBranch
|
|
if (project.name == 'next-minor-snapshot') {
|
|
// this is always a .x series
|
|
bwcBranch = "${bwcVersion.major}.x"
|
|
} else {
|
|
bwcBranch = "${bwcVersion.major}.${bwcVersion.minor}"
|
|
}
|
|
|
|
apply plugin: 'distribution'
|
|
// Not published so no need to assemble
|
|
tasks.remove(assemble)
|
|
build.dependsOn.remove('assemble')
|
|
|
|
File checkoutDir = file("${buildDir}/bwc/checkout-${bwcBranch}")
|
|
|
|
final String remote = System.getProperty("tests.bwc.remote", "elastic")
|
|
|
|
final boolean gitFetchLatest
|
|
final String gitFetchLatestProperty = System.getProperty("tests.bwc.git_fetch_latest", "true")
|
|
if ("true".equals(gitFetchLatestProperty)) {
|
|
gitFetchLatest = true
|
|
} else if ("false".equals(gitFetchLatestProperty)) {
|
|
gitFetchLatest = false
|
|
} else {
|
|
throw new GradleException("tests.bwc.git_fetch_latest must be [true] or [false] but was [" + gitFetchLatestProperty + "]")
|
|
}
|
|
|
|
task createClone(type: LoggedExec) {
|
|
onlyIf { checkoutDir.exists() == false }
|
|
commandLine = ['git', 'clone', rootDir, checkoutDir]
|
|
}
|
|
|
|
task findRemote(type: LoggedExec) {
|
|
dependsOn createClone
|
|
workingDir = checkoutDir
|
|
commandLine = ['git', 'remote', '-v']
|
|
ByteArrayOutputStream output = new ByteArrayOutputStream()
|
|
standardOutput = output
|
|
doLast {
|
|
project.ext.remoteExists = false
|
|
output.toString('UTF-8').eachLine {
|
|
if (it.contains("${remote}\t")) {
|
|
project.ext.remoteExists = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task addRemote(type: LoggedExec) {
|
|
dependsOn findRemote
|
|
onlyIf { project.ext.remoteExists == false }
|
|
workingDir = checkoutDir
|
|
commandLine = ['git', 'remote', 'add', "${remote}", "https://github.com/${remote}/elasticsearch.git"]
|
|
}
|
|
|
|
task fetchLatest(type: LoggedExec) {
|
|
onlyIf { project.gradle.startParameter.isOffline() == false && gitFetchLatest }
|
|
dependsOn addRemote
|
|
workingDir = checkoutDir
|
|
commandLine = ['git', 'fetch', '--all']
|
|
}
|
|
|
|
String buildMetadataKey = "bwc_refspec_${project.path.substring(1)}"
|
|
task checkoutBwcBranch(type: LoggedExec) {
|
|
String refspec = System.getProperty("tests.bwc.refspec.${bwcBranch}", buildMetadata.get(buildMetadataKey, "${remote}/${bwcBranch}"))
|
|
dependsOn fetchLatest
|
|
workingDir = checkoutDir
|
|
commandLine = ['git', 'checkout', refspec]
|
|
doFirst {
|
|
println "Checking out elasticsearch ${refspec} for branch ${bwcBranch}"
|
|
}
|
|
}
|
|
|
|
File buildMetadataFile = project.file("build/${project.name}/build_metadata")
|
|
task writeBuildMetadata(type: LoggedExec) {
|
|
dependsOn checkoutBwcBranch
|
|
workingDir = checkoutDir
|
|
commandLine = ['git', 'rev-parse', 'HEAD']
|
|
ignoreExitValue = true
|
|
ByteArrayOutputStream output = new ByteArrayOutputStream()
|
|
standardOutput = output
|
|
doLast {
|
|
if (execResult.exitValue != 0) {
|
|
output.toString('UTF-8').eachLine { line -> logger.error(line) }
|
|
execResult.assertNormalExitValue()
|
|
}
|
|
project.mkdir(buildMetadataFile.parent)
|
|
String commit = output.toString('UTF-8')
|
|
buildMetadataFile.setText("${buildMetadataKey}=${commit}", 'UTF-8')
|
|
println "Checked out elasticsearch commit ${commit}"
|
|
}
|
|
}
|
|
|
|
List<File> artifactFiles = []
|
|
List<String> projectDirs = []
|
|
for (String project : ['zip', 'deb', 'rpm']) {
|
|
String baseDir = "distribution"
|
|
if (bwcVersion.onOrAfter('6.3.0')) {
|
|
baseDir += project == 'zip' ? '/archives' : '/packages'
|
|
// add oss variant first
|
|
projectDirs.add("${baseDir}/oss-${project}")
|
|
artifactFiles.add(file("${checkoutDir}/${baseDir}/oss-${project}/build/distributions/elasticsearch-oss-${bwcVersion}.${project}"))
|
|
}
|
|
projectDirs.add("${baseDir}/${project}")
|
|
artifactFiles.add(file("${checkoutDir}/${baseDir}/${project}/build/distributions/elasticsearch-${bwcVersion}.${project}"))
|
|
}
|
|
|
|
task buildBwcVersion(type: Exec) {
|
|
dependsOn checkoutBwcBranch, writeBuildMetadata
|
|
// send RUNTIME_JAVA_HOME so the build doesn't fails on newer version the branch doesn't know about
|
|
environment('RUNTIME_JAVA_HOME', getJavaHome(it, rootProject.ext.minimumRuntimeVersion.getMajorVersion() as int))
|
|
workingDir = checkoutDir
|
|
// we are building branches that are officially built with JDK 8, push JAVA8_HOME to JAVA_HOME for these builds
|
|
if (["5.6", "6.0", "6.1"].contains(bwcBranch)) {
|
|
environment('JAVA_HOME', getJavaHome(it, 8))
|
|
} else if ("6.2".equals(bwcBranch)) {
|
|
environment('JAVA_HOME', getJavaHome(it, 9))
|
|
} else if (["6.3", "6.x"].contains(bwcBranch)) {
|
|
environment('JAVA_HOME', getJavaHome(it, 10))
|
|
} else {
|
|
environment('JAVA_HOME', project.compilerJavaHome)
|
|
}
|
|
if (Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
executable 'cmd'
|
|
args '/C', 'call', new File(checkoutDir, 'gradlew').toString()
|
|
} else {
|
|
executable new File(checkoutDir, 'gradlew').toString()
|
|
}
|
|
for (String dir : projectDirs) {
|
|
args ":${dir.replace('/', ':')}:assemble"
|
|
}
|
|
args "-Dbuild.snapshot=true"
|
|
final LogLevel logLevel = gradle.startParameter.logLevel
|
|
if ([LogLevel.QUIET, LogLevel.WARN, LogLevel.INFO, LogLevel.DEBUG].contains(logLevel)) {
|
|
args "--${logLevel.name().toLowerCase(Locale.ENGLISH)}"
|
|
}
|
|
final String showStacktraceName = gradle.startParameter.showStacktrace.name()
|
|
assert ["INTERNAL_EXCEPTIONS", "ALWAYS", "ALWAYS_FULL"].contains(showStacktraceName)
|
|
if (showStacktraceName.equals("ALWAYS")) {
|
|
args "--stacktrace"
|
|
} else if (showStacktraceName.equals("ALWAYS_FULL")) {
|
|
args "--full-stacktrace"
|
|
}
|
|
standardOutput = new IndentingOutputStream(System.out)
|
|
errorOutput = new IndentingOutputStream(System.err)
|
|
doLast {
|
|
List missing = artifactFiles.grep { file ->
|
|
false == file.exists()
|
|
}
|
|
if (false == missing.empty) {
|
|
throw new InvalidUserDataException(
|
|
"Building bwc version didn't generate expected files ${missing}")
|
|
}
|
|
}
|
|
}
|
|
|
|
artifacts {
|
|
for (File artifactFile : artifactFiles) {
|
|
String artifactName = artifactFile.name.contains('oss') ? 'elasticsearch-oss' : 'elasticsearch'
|
|
String suffix = artifactFile.toString()[-3..-1]
|
|
'default' file: artifactFile, name: artifactName, type: suffix, builtBy: buildBwcVersion
|
|
}
|
|
}
|
|
}
|
|
|
|
class IndentingOutputStream extends OutputStream {
|
|
|
|
public static final byte[] INDENT = " [bwc] ".getBytes(StandardCharsets.UTF_8)
|
|
private final OutputStream delegate
|
|
|
|
public IndentingOutputStream(OutputStream delegate) {
|
|
this.delegate = delegate
|
|
}
|
|
|
|
@Override
|
|
public void write(int b) {
|
|
write([b] as int[], 0, 1)
|
|
}
|
|
|
|
public void write(int[] bytes, int offset, int length) {
|
|
for (int i = 0; i < bytes.length; i++) {
|
|
delegate.write(bytes[i])
|
|
if (bytes[i] == '\n') {
|
|
delegate.write(INDENT)
|
|
}
|
|
}
|
|
}
|
|
} |