build.gradle

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF 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.
 */

buildscript {
  repositories {
    maven { url "https://plugins.gradle.org/m2/" }
    maven { url "https://dl.bintray.com/palantir/releases" }
    jcenter()
    maven { url "http://geode-maven.s3-website-us-west-2.amazonaws.com" }
  }

  dependencies {
    classpath "org.ajoberstar:gradle-git:1.3.2"
    classpath "gradle.plugin.org.nosphere.apache:creadur-rat-gradle:0.2.0"
    classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:2.6.2'
    classpath "com.diffplug.spotless:spotless-plugin-gradle:3.10.0"
    classpath "me.champeau.gradle:jmh-gradle-plugin:0.4.7"
    classpath "com.pedjak.gradle.plugins:dockerized-test:0.5.6.2-SNAPSHOT"
    classpath 'com.github.ben-manes:gradle-versions-plugin:0.17.0'
    classpath "com.netflix.nebula:nebula-project-plugin:4.0.1"
  }
}

apply plugin: 'wrapper'
apply plugin: 'nebula.facet'

wrapper {
  gradleVersion = minimumGradleVersion
}

// Load all properties in dependency-version.properties as project properties, so all projects can read them
Properties dependencyVersions = new Properties()
dependencyVersions.load(new FileInputStream("${project.projectDir}/gradle/dependency-versions.properties"))
dependencyVersions.keys().each{ k -> project.ext[k] = dependencyVersions[k]}

allprojects {
  version = versionNumber + releaseQualifier + releaseType
  ext.isReleaseVersion = !version.endsWith("SNAPSHOT")

  // We want to see all test results.  This is equivalent to setting --continue
  // on the command line.
  gradle.startParameter.continueOnFailure = true

  repositories {
    mavenCentral()
    maven { url "http://repo.spring.io/release" }
  }

  group = "org.apache.geode"

  buildRoot = buildRoot.trim()
  if (!buildRoot.isEmpty()) {
    buildDir = buildRoot + project.path.replace(":", "/") + "/build"
  }
}

// allow external projects to override include location
if (name == 'geode') {
  ext.scriptDir = 'gradle'
}

// utilities.gradle MUST be read before publish.gradle for reasons
apply from: "${scriptDir}/utilities.gradle"
apply from: "${scriptDir}/java.gradle"
apply from: "${scriptDir}/ide.gradle"
apply from: "${scriptDir}/dependency-resolution.gradle"
apply from: "${scriptDir}/test.gradle"
apply from: "${scriptDir}/test-by-category.gradle"
apply from: "${scriptDir}/publish.gradle"
apply from: "${scriptDir}/code-analysis.gradle"
apply from: "${scriptDir}/sonar.gradle"
apply from: "${scriptDir}/rat.gradle"
apply from: "${scriptDir}/docker.gradle"
apply from: "${scriptDir}/spotless.gradle"

subprojects {
  apply plugin: 'com.github.ben-manes.versions'
}

task devBuild(dependsOn: [":assemble"]) {
  description "A convenience target for a typical developer workflow: apply spotless and assemble all classes."
  // spotless targets are not available until after evaluation.
  subprojects {
    afterEvaluate {
      this.devBuild.dependsOn(project.spotlessApply)
    }
  }
}



def readScmInfo() {
  // Attempt to read git information, or else return UNKNOWN
  try {
    def git = org.ajoberstar.grgit.Grgit.open(currentDir: projectDir)
    try {
      return [
          'Source-Repository': git.branch.getCurrent().name,
          'Source-Revision'  : git.head().id,
          'Source-Date'      : git.head().getDate().format('yyyy-MM-dd HH:mm:ss Z')
      ] as Properties
    } finally {
      git.close()
    }
  } catch (IllegalArgumentException ignoredDistributionBuild) {
    // If we're building from the source distribution, we don't have git.
    // Instead, we use the .buildinfo copied to the root directory during the distribution build
    // from the writeBuildInfo task below (from build/.buildinfo)
    def buildInfo = file "$rootDir/.buildinfo"
    if (buildInfo.exists()) {
      def props = new Properties()
      new FileInputStream(buildInfo).withStream { fis ->
        props.load(fis)
      }
      return props
    }
    throw new GradleException("Cannot get SCM information when neither git nor source distribution is available")
  }
}

task writeBuildInfo {
  def buildInfo = file "$buildDir/.buildinfo"
  def scmInfo = rootProject.readScmInfo()

  inputs.property("Source-Revision", scmInfo.getProperty("Source-Revision"))
  outputs.file buildInfo
  doLast {
    buildInfo.getParentFile().mkdirs()
    new FileOutputStream(buildInfo).withStream { fos ->
      scmInfo.store(fos, '')
    }
  }
}

task generate() {
  group = 'Build'
  description = "Top-level target for all source generation. Helps IDE integration"
}