build.gradle

/*
 * Copyright 2010 the original author or authors.
 *
 * Licensed 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.gradle.build.Install
import org.gradle.cleanup.EmptyDirectoryCheck

defaultTasks 'assemble'
apply plugin: 'java-base'
apply plugin: 'build-types'
archivesBaseName = 'gradle'

buildTypes {
    sanityCheck {
        tasks "classes", "doc:checkstyleApi", "codeQuality", "docs:check"
    }

    // The minimum to be run before check-in
    preCommitBuild {
        tasks "doc:checkstyleApi", "docs:check", "codeQuality", "test"
    }
    quickCheck {
        tasks "doc:checkstyleApi", "docs:check", "codeQuality", "test"
    }

    // For testing pull requests
    pullRequestValidation {
        tasks "doc:checkstyleApi", "docs:check", "codeQuality", "core:test", "dependencyManagement:test"
    }

    // A full (in-process) test
    developerBuild {
        tasks "check"
    }

    // Used by the first phase of the build pipeline, running only last version on multiversion - tests
    quickTest {
        tasks "runtimeTests", "runtimeIntegTests"
    }

    // Used for builds to run all tests, but not necessarily on all platforms
    fullTest {
        tasks "runtimeTests", "runtimeForkingIntegTests"
        projectProperties useIncomingDistributions: true, testAllVersions: true
    }

    // Used for builds to test the code on certain platforms
    platformTest {
        tasks "runtimeTests", "runtimeForkingIntegTests"
        projectProperties useIncomingDistributions: true, testAllVersions: true, testAllPlatforms: true
    }

    // Tests not using the daemon mode
    noDaemonTest {
        tasks "runtimeNoDaemonIntegTests"
        projectProperties useIncomingDistributions: true
    }

    // Run the integration tests using the parallel executer
    parallelTest {
        tasks "runtimeParallelIntegTests"
        projectProperties useIncomingDistributions: true
    }

    performanceTests {
        tasks "performance:performanceTest"
        projectProperties useIncomingDistributions: true
    }

    performanceExperiments {
        tasks "performance:performanceExperiments"
        projectProperties useIncomingDistributions: true
    }

    fullPerformanceTests {
        tasks "performance:fullPerformanceTest"
        projectProperties useIncomingDistributions: true
    }

    distributedPerformanceTests {
        tasks "performance:distributedPerformanceTest"
        projectProperties useIncomingDistributions: true
    }

    distributedPerformanceExperiments {
        tasks "performance:distributedPerformanceExperiment"
        projectProperties useIncomingDistributions: true
    }

    distributedFullPerformanceTests {
        tasks "performance:distributedFullPerformanceTest"
        projectProperties useIncomingDistributions: true
    }

    // Used for cross version tests on CI
    crossVersionTest {
        tasks "crossVersionIntegTest"
        projectProperties useIncomingDistributions: true
    }
    quickFeedbackCrossVersionTest {
        tasks "quickFeedbackCrossVersionIntegTest"
        projectProperties useIncomingDistributions: true
    }

    // Used to build production distros and smoke test them
    packageBuild {
        tasks "verifyIsProductionBuildEnvironment", "clean", "buildDists", "distributions:integTest"
    }

    // Used to build (experimental) production distros and smoke test them
    packageBuildExperimental {
        tasks "verifyIsProductionBuildEnvironment", "buildDists", "distributions:integTest"
    }

    // Used to build production distros and smoke test them
    promotionBuild {
        tasks "verifyIsProductionBuildEnvironment", "clean", "docs:check", "buildDists", "distributions:integTest", "uploadArchives"
    }

    //Initial smoke test for java 9
    java9Build {
        tasks "java9Test", "java9IntegTest"
        projectProperties useIncomingDistributions: true
    }
    java9SmokeTest {
        tasks "java9IntegTest"
        projectProperties useIncomingDistributions: true
    }

    soakTest {
        tasks "soak:soakTest"
        projectProperties testAllVersions: true
    }
}

apply from: "gradle/testGroupings.gradle"
apply from: 'gradle/buildSplits.gradle'
ext {
    jvm = org.gradle.internal.jvm.Jvm.current()
    javaVersion = JavaVersion.current()
    isCiServer = System.getenv().containsKey("CI")
    isWindows = org.gradle.internal.os.OperatingSystem.current().windows

    if (project.hasProperty("maxParallelForks")) {
        project.maxParallelForks = Integer.valueOf(project.maxParallelForks, 10)
    } else {
        ext.maxParallelForks = 4
    }

    if (project.hasProperty("useIncomingDistributions")) {
        project.useIncomingDistributions = true
    } else {
        ext.useIncomingDistributions = false
    }

    agentNum = 1
    if (System.getenv().containsKey("USERNAME")) {
        def agentNumEnv = System.getenv("USERNAME") - "tcagent"
        if (agentNumEnv ==~ /\d+/) {
            agentNum = agentNumEnv
        }
    }

    internalProjects = subprojects.findAll { it.name.startsWith("internal") || it.name in ["integTest", "distributions", "performance", "buildScanPerformance"] }
    groovyProjects = subprojects
    publicGroovyProjects = groovyProjects - internalProjects
    pluginProjects = [
        'plugins', 'codeQuality', 'antlr', 'wrapper', 'osgi', 'maven',
        'ide', 'announce', 'scala', 'signing', 'ear', 'javascript', 'buildComparison',
        'diagnostics', 'reporting', 'publish', 'ivy', 'jacoco', 'buildInit', 'platformBase',
        'platformJvm', 'languageJvm', 'languageJava', 'languageGroovy', 'languageScala',
        'platformNative', 'platformPlay', 'idePlay', 'languageNative', 'ideNative', 'testingBase',
        'testingNative', 'testingJvm', 'pluginDevelopment', 'pluginUse', 'resourcesHttp',
        'resourcesSftp', 'resourcesS3', 'compositeBuilds', 'buildCacheHttp'
    ].collect {
        project(it)
    }
    implementationPluginProjects = [
            'toolingApiBuilders'
    ].collect {
        project(it)
    }
    publishedProjects = [
        project(':logging'),
        project(':core'),
        project(':modelCore'),
        project(':toolingApi'),
        project(':wrapper'),
        project(':baseServices'),
        project(':baseServicesGroovy'),
        project(':workers'),
        project(':dependencyManagement'),
        project(':messaging'),
        project(':processServices'),
        project(':resources')
    ]
    removedProjects = ['sonar']
}

apply from: "gradle/buildScanUserData.gradle"
apply from: "gradle/taskCacheBuildScanUserData.gradle"
apply from: "gradle/incomingDistributions.gradle"
apply from: "gradle/versioning.gradle"
apply from: "gradle/dependencies.gradle"
apply from: "gradle/wrapper.gradle"
apply from: "gradle/idea.gradle"
apply from: "gradle/eclipse.gradle"
apply from: "gradle/classycle.gradle"
apply from: "gradle/strictCompile.gradle"
apply from: "gradle/noDependencyResolutionDuringConfiguration.gradle"
apply from: "gradle/testSetup.gradle"
apply from: "gradle/fix-GRADLE-2492.gradle"
apply from: 'gradle/customM2Check.gradle'

allprojects {
    group = 'org.gradle'

    repositories {
        maven { url 'https://repo.gradle.org/gradle/libs-releases' }
        maven { url 'https://repo.gradle.org/gradle/libs-milestones' }
        maven { url "https://repo.gradle.org/gradle/libs-snapshots" }
    }

    // patchExternalModules lives in the root project - we need to activate normalization there, too.
    normalization {
        runtimeClasspath {
            ignore 'org/gradle/build-receipt.properties'
        }
    }
}

subprojects {
    version = rootProject.version

    if (project in groovyProjects) {
        apply from: "$rootDir/gradle/groovyProject.gradle"
        apply from: "$rootDir/gradle/testWithUnknownOS.gradle"
        apply from: "$rootDir/gradle/java9.gradle"
        check.dependsOn ":docs:checkstyleApi"
        check.dependsOn "codeQuality"
    }

    if (project in publishedProjects) {
        apply from: "$rootDir/gradle/publish.gradle"
    }

    apply from: "$rootDir/gradle/codeQuality.gradle"

    if (isCiServer) {
        reporting.baseDir "$rootProject.reporting.baseDir/${path.replaceFirst(':', '').replaceAll(':', '.')}"
    }
}

configurations {
    coreRuntime {
        visible = false
    }
    externalModules {
        visible = false
    }
    // Configuration used to resolve external modules before patching them with versions from core runtime
    externalModulesRuntime {
        visible = false
        extendsFrom coreRuntime
        extendsFrom externalModules
    }
    // Combines the 'coreRuntime' with the patched external module jars
    runtime {
        visible = false
        extendsFrom coreRuntime
    }
    gradlePlugins {
        visible = false
    }
    testRuntime {
        extendsFrom runtime
        extendsFrom gradlePlugins
    }
}

def patchedExternalModulesDir = new File(buildDir, "external/files")
def patchedExternalModules = files({ -> fileTree(patchedExternalModulesDir).files.sort() })
patchedExternalModules.builtBy 'patchExternalModules'

dependencies {
    externalModules 'org.gradle:gradle-script-kotlin:0.9.1'
    externalModules 'org.gradle:gradle-script-kotlin-tooling-builders:0.9.1'
    coreRuntime project(':launcher')
    coreRuntime project(':runtimeApiInfo')
    runtime project(':wrapper')
    runtime project(":installationBeacon")
    runtime patchedExternalModules
    gradlePlugins pluginProjects
    gradlePlugins implementationPluginProjects
    gradlePlugins project(':workers')
    gradlePlugins project(':dependencyManagement')
    gradlePlugins project(':testKit')
}

import org.gradle.modules.PatchExternalModules

task patchExternalModules(type: PatchExternalModules) {
    allModules = configurations.externalModulesRuntime
    coreModules = configurations.coreRuntime
    modulesToPatch = configurations.externalModules
    destination = patchedExternalModulesDir
}

task verifyIsProductionBuildEnvironment {
    doLast {
        assert javaVersion.java7: "Must use a Java 7 compatible JVM to perform this build. Current JVM is ${jvm}"
        def systemCharset = java.nio.charset.Charset.defaultCharset().name()
        assert systemCharset == "UTF-8": "Platform encoding must be UTF-8. Is currently $systemCharset. Set -Dfile.encoding=UTF-8."
    }
}

task waitForDaemonsToDie {
    if (!project.hasProperty("noWaitForDaemonsToDie")) {
        if (isWindows && isCiServer && buildTypes.crossVersionTest.active) {
            gradle.startParameter.taskNames.add(0, it.path)
        }
        doLast {
            def mins = 2
            println "I'm waiting for $mins mins so that existing daemons can die with honour. It's a workaround until we fix it properly."
            sleep mins * 60 * 1000
        }
    }
}

evaluationDependsOn ":distributions"

task install(type: Install) {
    description = 'Installs the minimal distribution into directory $gradle_installPath'
    group = 'build'
    with project(":distributions").binDistImage
    installDirPropertyName = 'gradle_installPath'
}

task installAll(type: Install) {
    description = 'Installs the full distribution into directory $gradle_installPath'
    group = 'build'
    with project(":distributions").allDistImage
    installDirPropertyName = 'gradle_installPath'
}

apply from: "gradle/intTestImage.gradle"
apply from: 'gradle/pullRequestBuild.gradle'

// Generate a report showing which tests in a subproject are leaving
// files around.
//
// Once a subproject's report is "clean" we should add the following to that
// subproject's buildscript:
//
// verifyTestFilesCleanup.errorWhenNotEmpty = true
//
subprojects { prj ->
    task verifyTestFilesCleanup(type: EmptyDirectoryCheck) {
        targetDir = prj.fileTree("${prj.buildDir}/tmp/test files")
        report = prj.file("${prj.buildDir}/reports/remains.txt")
        errorWhenNotEmpty = true
    }
}

task cleanUpRemovedProjects(type: Delete) {
    delete removedProjects.collect { "subprojects/$it" }
}
clean.dependsOn(cleanUpRemovedProjects)

gradle.buildFinished { result ->
    def rootProject = result.gradle.rootProject
    if (rootProject.remoteBuildCacheEnabled && !rootProject.java7HomeSet) {
        logger.warn("In order to have cache hits from the remote build cache you need to set 'java7Home' in your gradle.properties!")
    }
}

/*
 * When run from a Continuous Integration environment HTML test reports will usually only be inspected
 * if the build failed e.g. due to failed or flaky tests.
 *
 * Deletes HTML test reports so they are not archived on TeamCity and use up unnecessary disk space.
 */
if (isCiServer) {
    gradle.buildFinished { buildResult ->
        if (!buildResult.failure) {
            logger.quiet "Deleting HTML test reports..."

            subprojects {
                def htmlTestReportDirs = tasks.withType(Test).collect { it.reports.html.destination }.unique()

                htmlTestReportDirs.each { htmlReportDir ->
                    logger.info "Deleting test reports directory '$htmlReportDir'."
                    def success = htmlReportDir.deleteDir()

                    if (!success) {
                        logger.warn "Unable to delete test report directory '$htmlReportDir'."
                    }
                }
            }
        }
    }
}