build.gradle

/*
 * 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 java.util.regex.Matcher
import java.nio.file.Path
import org.eclipse.jgit.lib.Repository
import org.eclipse.jgit.lib.RepositoryBuilder
import org.gradle.plugins.ide.eclipse.model.SourceFolder
import org.apache.tools.ant.taskdefs.condition.Os
import org.elasticsearch.gradle.VersionProperties
import org.elasticsearch.gradle.Version

// common maven publishing configuration
subprojects {
  group = 'com.strapdata.elasticsearch'
  version = org.elasticsearch.gradle.VersionProperties.elasticsearch
  description = "Elasticsearch subproject ${project.path}"
}

ext.enableArtifactSigning = !version.endsWith("SNAPSHOT") && project.hasProperty("repoUsername")
ext.repoUsername = { project.hasProperty("repoUsername") ? getProperty("repoUsername") : "" }
ext.repoPassword = { project.hasProperty("repoPassword") ? getProperty("repoPassword") : "" }

Path rootPath = rootDir.toPath()
// setup pom license info, but only for artifacts that are part of elasticsearch
configure(subprojects.findAll { it.projectDir.toPath().startsWith(rootPath) }) {
    apply plugin: 'maven'
    apply plugin: 'signing'
  
  repositories {
    mavenLocal()
    maven {
        url "https://oss.sonatype.org/content/repositories/snapshots/"
    }
  }
    
  // we only use maven publish to add tasks for pom generation
  plugins.withType(MavenPublishPlugin).whenPluginAdded {
    publishing {
      publications {
          // add license information to generated poms
          all {
           pom.withXml { XmlProvider xml ->
            Node node = xml.asNode()
            node.appendNode('inceptionYear', '2015')

            Node license = node.appendNode('licenses').appendNode('license')
            license.appendNode('name', 'The Apache Software License, Version 2.0')
            license.appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.txt')
            license.appendNode('distribution', 'repo')

            Node developer = node.appendNode('developers').appendNode('developer')
            developer.appendNode('name', 'Strapdata')
            developer.appendNode('url', 'http://www.strapdata.com')
           }
         }
         
         maven(MavenPublication) {
            if (components.hasProperty('java')) {
                from components.java
                artifacts { 
                    archives sourcesJar 
                    archives javadocJar
                }
             }
         }
      }
    }
    
    if (enableArtifactSigning) {
       signing {
         sign configurations.archives
       }
    }

    // OSSRH publication
    uploadArchives {
        repositories {
            mavenDeployer {
                uploadDescriptor = true
                
                // POM signature
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
                
                // Target repository
                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: repoUsername, password: repoPassword)
                }

                // SNAPSHOT repository
                snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                    authentication(userName: repoUsername, password: repoPassword)
                }
                
                pom.withXml { XmlProvider xml ->
                    Node node = xml.asNode()
                    node.appendNode('name',it.name)
                    node.appendNode('description',"Elasticsearch subproject ${project.path}")
                    node.appendNode('url', 'http://github.com/strapdata/elassandra')
                    node.appendNode('inceptionYear', '2015')
        
                    Node license = node.appendNode('licenses').appendNode('license')
                    license.appendNode('name', 'The Apache Software License, Version 2.0')
                    license.appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.txt')
                    license.appendNode('distribution', 'repo')
                    
                    def scm = node.appendNode('scm')
                    scm.appendNode('url', 'http://github.com/strapdata/elassandra')
                    scm.appendNode('connection', 'scm:git:git@github.com:strapdata/elassandra.git')
                    scm.appendNode('developerConnection', 'scm:git:git@github.com:strapdata/elassandra.git')
                    
                    Node developer = node.appendNode('developers').appendNode('developer')
                    developer.appendNode('name', 'Strapdata')
                    developer.appendNode('url', 'https://github.com/strapdata/elassandra')
                    developer.appendNode('organizationUrl', 'http://www.strapdata.com/')
                }
            }
        }
    }
  }
}

// introspect all versions of ES that may be tested agains for backwards compatibility
Version currentVersion = Version.fromString(VersionProperties.elasticsearch.minus('-SNAPSHOT'))
File versionFile = file('core/src/main/java/org/elasticsearch/Version.java')
List<String> versionLines = versionFile.readLines('UTF-8')
List<Version> versions = []
// keep track of the major version's first version, so we know where wire compat begins
int firstMajorIndex = -1 // index in the versions list of the first minor from this major
for (String line : versionLines) {
  Matcher match = line =~ /\W+public static final Version V_(\d+)_(\d+)_(\d+)(_UNRELEASED)? .*/
  if (match.matches()) {
    int major = Integer.parseInt(match.group(1))
    int minor = Integer.parseInt(match.group(2))
    int bugfix = Integer.parseInt(match.group(3))
    boolean unreleased = match.group(4) != null
    Version foundVersion = new Version(major, minor, bugfix, false, unreleased)
    if (currentVersion != foundVersion) {
      versions.add(foundVersion)
    }
    if (major == currentVersion.major && firstMajorIndex == -1) {
      firstMajorIndex = versions.size() - 1
    }
  }
}
if (versions.toSorted { it.id } != versions) {
  println "Versions: ${versions}"
  throw new GradleException("Versions.java contains out of order version constants")
}
if (currentVersion.bugfix == 0) {
  // If on a release branch, after the initial release of that branch, the bugfix version will
  // be bumped, and will be != 0. On master and N.x branches, we want to test against the
  // unreleased version of closest branch. So for those cases, the version includes -SNAPSHOT,
  // and the bwc distribution will checkout and build that version.
  Version last = versions[-1]
  versions[-1] = new Version(last.major, last.minor, last.bugfix,
      true, last.unreleased)
}

// injecting groovy property variables into all projects
allprojects {
  // injecting groovy property variables into all projects
  project.ext {
    // for ide hacks...
    isEclipse = System.getProperty("eclipse.launcher") != null || gradle.startParameter.taskNames.contains('eclipse') || gradle.startParameter.taskNames.contains('cleanEclipse')
    isIdea = System.getProperty("idea.active") != null || gradle.startParameter.taskNames.contains('idea') || gradle.startParameter.taskNames.contains('cleanIdea')
    // for backcompat testing
    indexCompatVersions = versions
    wireCompatVersions = versions.subList(firstMajorIndex, versions.size())

    // elassandra adds a 4th digit to the version number
    elassVersion = VersionProperties.elassandra
    // full version number including the elassandra added digit, and taking care of eventual "-SNAPSHOT" suffix

    if (version.endsWith("-SNAPSHOT")) {
      fullElassVersion = "${version.minus('-SNAPSHOT')}.${elassVersion}-SNAPSHOT"
    }
    else {
      fullElassVersion = "${version}.${elassVersion}"
    }
  }
}

task verifyVersions {
  doLast {
    if (gradle.startParameter.isOffline()) {
      throw new GradleException("Must run in online mode to verify versions")
    }
    // Read the list from maven central
    Node xml
    new URL('https://oss.sonatype.org/content/repositories/snapshots/com/strapdata/elasticsearch/elasticsearch/maven-metadata.xml').openStream().withStream { s ->
        xml = new XmlParser().parse(s)
    }
    Set<Version> knownVersions = new TreeSet<>(xml.versioning.versions.version.collect { it.text() }.findAll { it ==~ /\d\.\d\.\d/ }.collect { Version.fromString(it) })

    // Limit the known versions to those that should be index compatible, and are not future versions
    knownVersions = knownVersions.findAll { it.major >= 2 && it.before(VersionProperties.elasticsearch) }

    /* Limit the listed versions to those that have been marked as released.
     * Versions not marked as released don't get the same testing and we want
     * to make sure that we flip all unreleased versions to released as soon
     * as possible after release. */
    Set<Version> actualVersions = new TreeSet<>(indexCompatVersions.findAll { false == it.snapshot })

    // Finally, compare!
    if (knownVersions.equals(actualVersions) == false) {
      throw new GradleException("out-of-date released versions\nActual  :" + actualVersions + "\nExpected:" + knownVersions +
        "\nUpdate Version.java. Note that Version.CURRENT doesn't count because it is not released.")
    }
  }
}

task branchConsistency {
  description 'Ensures this branch is internally consistent. For example, that versions constants match released versions.'
  group 'Verification'
  dependsOn verifyVersions
}

subprojects {
  project.afterEvaluate {
    // include license and notice in jars
    tasks.withType(Jar) {
      into('META-INF') {
        from project.rootProject.rootDir
        include 'LICENSE.txt'
        include 'NOTICE.txt'
      }
    }
    // ignore missing javadocs
    tasks.withType(Javadoc) { Javadoc javadoc ->
      // the -quiet here is because of a bug in gradle, in that adding a string option
      // by itself is not added to the options. By adding quiet, both this option and
      // the "value" -quiet is added, separated by a space. This is ok since the javadoc
      // command already adds -quiet, so we are just duplicating it
      // see https://discuss.gradle.org/t/add-custom-javadoc-option-that-does-not-take-an-argument/5959
      javadoc.options.encoding='UTF8'
      javadoc.options.addStringOption('Xdoclint:all,-missing', '-quiet')
      /*
      TODO: building javadocs with java 9 b118 is currently broken with weird errors, so
      for now this is commented out...try again with the next ea build...
      javadoc.executable = new File(project.javaHome, 'bin/javadoc')
      if (project.javaVersion == JavaVersion.VERSION_1_9) {
        // TODO: remove this hack! gradle should be passing this...
        javadoc.options.addStringOption('source', '8')
      }*/
    }
  }

  /* Sets up the dependencies that we build as part of this project but
    register as thought they were external to resolve internally. We register
    them as external dependencies so the build plugin that we use can be used
    to build elasticsearch plugins outside of the elasticsearch source tree. */
  ext.projectSubstitutions = [
    "com.strapdata.elasticsearch.gradle:build-tools:${version}": ':build-tools',
    "org.elasticsearch:rest-api-spec:${version}": ':rest-api-spec',
    "com.strapdata.elasticsearch:elasticsearch:${version}": ':core',
    "com.strapdata.elasticsearch.client:rest:${version}": ':client:rest',
    "com.strapdata.elasticsearch.client:sniffer:${version}": ':client:sniffer',
    "com.strapdata.elasticsearch.client:test:${version}": ':client:test',
    "com.strapdata.elasticsearch.client:transport:${version}": ':client:transport',
    "com.strapdata.elasticsearch.test:framework:${version}": ':test:framework',
    "com.strapdata.elasticsearch.distribution.integ-test-zip:elasticsearch:${version}": ':distribution:integ-test-zip',
    "com.strapdata.elasticsearch.distribution.zip:elasticsearch:${version}": ':distribution:zip',
    "com.strapdata.elasticsearch.distribution.tar:elasticsearch:${version}": ':distribution:tar',
    "com.strapdata.elasticsearch.distribution.rpm:elasticsearch:${version}": ':distribution:rpm',
    "com.strapdata.elasticsearch.distribution.deb:elasticsearch:${version}": ':distribution:deb',
    "com.strapdata.elasticsearch.test:logger-usage:${version}": ':test:logger-usage',
    // for transport client
    "com.strapdata.elasticsearch.plugin:transport-netty3-client:${version}": ':modules:transport-netty3',
    "com.strapdata.elasticsearch.plugin:transport-netty4-client:${version}": ':modules:transport-netty4',
    "com.strapdata.elasticsearch.plugin:reindex-client:${version}": ':modules:reindex',
    "com.strapdata.elasticsearch.plugin:lang-mustache-client:${version}": ':modules:lang-mustache',
    "com.strapdata.elasticsearch.plugin:parent-join-client:${version}": ':modules:parent-join',
    "com.strapdata.elasticsearch.plugin:aggs-matrix-stats-client:${version}": ':modules:aggs-matrix-stats',
    "com.strapdata.elasticsearch.plugin:percolator-client:${version}": ':modules:percolator',
  ]
  if (wireCompatVersions[-1].snapshot) {
    // if the most previous version is a snapshot, we need to connect that version to the
    // bwc project which will checkout and build that snapshot version
    ext.projectSubstitutions["com.strapdata.elasticsearch.distribution.deb:elasticsearch:${wireCompatVersions[-1]}"] = ':distribution:bwc'
    ext.projectSubstitutions["com.strapdata.elasticsearch.distribution.rpm:elasticsearch:${wireCompatVersions[-1]}"] = ':distribution:bwc'
    ext.projectSubstitutions["com.strapdata.elasticsearch.distribution.zip:elasticsearch:${wireCompatVersions[-1]}"] = ':distribution:bwc'
  }
  project.afterEvaluate {
    configurations.all {
      resolutionStrategy.dependencySubstitution { DependencySubstitutions subs ->
        projectSubstitutions.each { k,v ->
          subs.substitute(subs.module(k)).with(subs.project(v))
        }
      }
    }
  }
}

// Ensure similar tasks in dependent projects run first. The projectsEvaluated here is
// important because, while dependencies.all will pickup future dependencies,
// it is not necessarily true that the task exists in both projects at the time
// the dependency is added.
gradle.projectsEvaluated {
  allprojects {
    if (project.path == ':test:framework') {
      // :test:framework:test cannot run before and after :core:test
      return
    }
    configurations.all {
      dependencies.all { Dependency dep ->
        Project upstreamProject = null
        if (dep instanceof ProjectDependency) {
          upstreamProject = dep.dependencyProject
        } else {
          // gradle doesn't apply substitutions until resolve time, so they won't
          // show up as a ProjectDependency above
          String substitution = projectSubstitutions.get("${dep.group}:${dep.name}:${dep.version}")
          if (substitution != null) {
            upstreamProject = findProject(substitution)
          }
        }
        if (upstreamProject != null) {
          if (project.path == upstreamProject.path) {
            // TODO: distribution integ tests depend on themselves (!), fix that
            return
          }
          for (String taskName : ['test', 'integTest']) {
            Task task = project.tasks.findByName(taskName)
            Task upstreamTask = upstreamProject.tasks.findByName(taskName)
            if (task != null && upstreamTask != null) {
              task.mustRunAfter(upstreamTask)
            }
          }
        }
      }
    }
  }
}

// intellij configuration
allprojects {
  apply plugin: 'idea'

  if (isIdea) {
    project.buildDir = file('build-idea')
  }
  idea {
    module {
      inheritOutputDirs = false
      outputDir = file('build-idea/classes/main')
      testOutputDir = file('build-idea/classes/test')

      // also ignore other possible build dirs
      excludeDirs += file('build')
      excludeDirs += file('build-eclipse')

      iml {
        // fix so that Gradle idea plugin properly generates support for resource folders
        // see also https://issues.gradle.org/browse/GRADLE-2975
        withXml {
          it.asNode().component.content.sourceFolder.findAll { it.@url == 'file://$MODULE_DIR$/src/main/resources' }.each {
            it.attributes().remove('isTestSource')
            it.attributes().put('type', 'java-resource')
          }
          it.asNode().component.content.sourceFolder.findAll { it.@url == 'file://$MODULE_DIR$/src/test/resources' }.each {
            it.attributes().remove('isTestSource')
            it.attributes().put('type', 'java-test-resource')
          }
        }
      }
    }
  }
}

idea {
  project {
    vcs = 'Git'
  }
}
// Make sure gradle idea was run before running anything in intellij (including import).
File ideaMarker = new File(projectDir, '.local-idea-is-configured')
tasks.idea.doLast {
  ideaMarker.setText('', 'UTF-8')
}
if (System.getProperty('idea.active') != null && ideaMarker.exists() == false) {
  throw new GradleException('You must run gradle idea from the root of elasticsearch before importing into IntelliJ')
}

// eclipse configuration
allprojects {
  apply plugin: 'eclipse'
  // Name all the non-root projects after their path so that paths get grouped together when imported into eclipse.
  if (path != ':') {
    eclipse.project.name = path
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
      eclipse.project.name = eclipse.project.name.replace(':', '_')
    }
  }

  plugins.withType(JavaBasePlugin) {
    File eclipseBuild = project.file('build-eclipse')
    eclipse.classpath.defaultOutputDir = eclipseBuild
    if (isEclipse) {
      // set this so generated dirs will be relative to eclipse build
      project.buildDir = eclipseBuild
    }
    eclipse.classpath.file.whenMerged { classpath ->
      // give each source folder a unique corresponding output folder
      int i = 0;
      classpath.entries.findAll { it instanceof SourceFolder }.each { folder ->
        i++;
        // this is *NOT* a path or a file.
        folder.output = "build-eclipse/" + i
      }
    }
  }
  task copyEclipseSettings(type: Copy) {
    // TODO: "package this up" for external builds
    from new File(project.rootDir, 'buildSrc/src/main/resources/eclipse.settings')
    into '.settings'
  }
  // otherwise .settings is not nuked entirely
  task wipeEclipseSettings(type: Delete) {
    delete '.settings'
  }
  tasks.cleanEclipse.dependsOn(wipeEclipseSettings)
  // otherwise the eclipse merging is *super confusing*
  tasks.eclipse.dependsOn(cleanEclipse, copyEclipseSettings)
}

// we need to add the same --debug-jvm option as
// the real RunTask has, so we can pass it through
class Run extends DefaultTask {
  boolean debug = false

  @org.gradle.api.internal.tasks.options.Option(
        option = "debug-jvm",
        description = "Enable debugging configuration, to allow attaching a debugger to elasticsearch."
  )
  public void setDebug(boolean enabled) {
    project.project(':distribution').run.clusterConfig.debug = enabled
  }
}
task run(type: Run) {
  dependsOn ':distribution:run'
  description = 'Runs elasticsearch in the foreground'
  group = 'Verification'
  impliesSubProjects = true
}