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

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", "performance:test"
    }

    // 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", "performance:test"
        projectProperties useIncomingDistributions: true, testAllVersions: true, testAllPlatforms: true
    }

    // Tests using the daemon mode
    daemonTest {
        tasks "runtimeDaemonIntegTests"
        projectProperties useIncomingDistributions: true
    }

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

    // Run the performance tests
    performanceTest {
        tasks "performance:performanceTest"
        projectProperties useIncomingDistributions: true
    }

    // Run the performance experiments
    performanceExperiments {
        tasks "performance:performanceExperiments"
        projectProperties useIncomingDistributions: true
    }

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

    // Used to build production distros and smoke test them
    packageBuild {
        tasks "verifyIsProductionBuildEnvironment", "clean", "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
    }
}

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("TEAMCITY_VERSION")
    isWindows = org.gradle.internal.os.OperatingSystem.current().windows

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

    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"] }
    groovyProjects = subprojects
    publicGroovyProjects = groovyProjects - internalProjects
    pluginProjects = [
        'plugins', 'codeQuality', 'jetty', 'antlr', 'wrapper', 'osgi', 'maven',
        'ide', 'announce', 'scala', 'sonar', 'signing', 'ear', 'javascript', 'buildComparison',
        'diagnostics', 'reporting', 'publish', 'ivy', 'jacoco', 'buildInit', 'platformBase',
        'platformJvm', 'languageJvm', 'languageJava', 'languageGroovy', 'languageScala',
        'platformNative', 'platformPlay', 'languageNative', 'ideNative', 'testingBase',
        'testingNative', 'testingJvm', 'pluginDevelopment', 'pluginUse', 'resourcesHttp',
        'resourcesSftp', 'resourcesS3', 'toolingApiBuilders'
    ].collect {
        project(it)
    }
    publishedProjects = [
        project(':core'),
        project(':toolingApi'),
        project(':wrapper'),
        project(':baseServices'),
        project(':baseServicesGroovy'),
        project(':messaging'),
        project(':resources')
    ]
}

apply from: "gradle/buildReceipt.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/taskOrdering.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' }
    }
}

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 {
    sonar {
        visible = false
    }
    runtime {
        visible = false
    }
    gradlePlugins {
        visible = false
    }
    testRuntime {
        extendsFrom runtime
        extendsFrom gradlePlugins
    }
}

dependencies {
    runtime project(':launcher')
    runtime project(':wrapper')
    runtime project(":installationBeacon")
    sonar libraries.logback_classic
    gradlePlugins pluginProjects
    gradlePlugins project(':dependencyManagement')
    gradlePlugins project(':testKit')
}

task verifyIsProductionBuildEnvironment << {
    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'
}

clean {
    dependsOn ':killExistingDaemons'
}

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

def reportsFolder = new File(buildDir, "reports")
ext.preferencesTraceFile = new File(reportsFolder, "preferences.trace.log")
def userPrefsDirectory = new File("${System.getProperty("user.home")}/.java/.userPrefs")

gradle.addListener(new TaskExecutionListener() {
    void beforeExecute(Task task) {
        if (task.name != "clean") {
            doLog("before executing ", task)
            if (userPrefsDirectory.exists()) {
                GFileUtils.forceDelete(userPrefsDirectory)
            }
        }
    }

    void afterExecute(Task task, TaskState state) {
        if (task.name != "clean") {
            doLog("after executing", task)
            if (userPrefsDirectory.exists()) {
                GFileUtils.forceDelete(userPrefsDirectory)
            }
        }
    }

    void doLog(String descr, Task task) {
        if (!reportsFolder.exists()) {
            reportsFolder.mkdirs()
        }
        preferencesTraceFile.createNewFile()
        preferencesTraceFile << "$descr , '${task.path}', ${userPrefsDirectory.absolutePath}, ${userPrefsDirectory.exists()}\n"
    }
})