build.gradle

/*
 * Licensed to Crate.io GmbH ("Crate") under one or more contributor
 * license agreements.  See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.  Crate 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.
 *
 * However, if you have executed another commercial license agreement
 * with Crate these terms will supersede the license and you may use the
 * software solely pursuant to the terms of the relevant commercial agreement.
 */

import com.github.jk1.license.filter.LicenseBundleNormalizer
import com.github.jk1.license.render.InventoryMarkdownReportRenderer
import io.crate.gradle.TestLogger

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'de.thetaphi:forbiddenapis:3.2'
    }
}

plugins {
    id 'com.github.jk1.dependency-license-report' version '2.1'
}

def download(File downloadDir, String url, String name) {
    downloadDir.mkdirs()
    def dest = new File(downloadDir, name)
    ant.get(
            src: url,
            verbose: true,
            usetimestamp: true,
            skipexisting: true,
            dest: dest
    )
    return dest
}

apply from: 'gradle/dependencies.gradle'
apply plugin: 'base'

repositories {
    mavenCentral()
}

boolean runSlowTests = System.getProperty("tests.crate.slow")
if (runSlowTests) {
    println "Configured to run the crate slow tests as well, grab yourself a coffee"
}

allprojects {
    apply plugin: 'jacoco'

    tasks.withType(Test) {
        useJUnitPlatform()

        // force run, see: http://gradle.1045684.n5.nabble.com/how-does-gradle-decide-when-to-run-tests-td3314172.html
        outputs.upToDateWhen { false }

        minHeapSize = "1024m"
        maxHeapSize = "1024m"

        // allow to set the number of test forks from the CLI
        if (project.hasProperty('testForks')) {
            maxParallelForks = project.testForks as int
            systemProperty "processors", Math.max(maxParallelForks / 2.0d, 1) as int
        }
        if (project.hasProperty('disableAssertions')) {
            enableAssertions = false
            // LuceneTestCase defaults this value to 'true' if not set which results in an exception if '-ea' is skipped
            systemProperty "tests.asserts", "false"
        }

        // tell ES to add required permissions for gradle
        systemProperty "tests.gradle", "true"
        systemProperty "file.encoding", "UTF-8"

        // pass system properties to gradle process
        // you you can filter tests by test groups,
        // e.g. -Dtests.nightly=true
        System.properties.keySet().each { item ->
            if (item.startsWith("tests.")) {
                systemProperty "$item", System.getProperty(item)
            }
        }
        if ("true".equals(System.getProperty("tests.verbose", "false").toLowerCase())) {
            // show which tests are actually run
            // very helpful if you want to see if your included/excluded tests are correct
            afterTest { descriptor, result ->
              logger.lifecycle(" # " + descriptor + " -> " + result)
            }
        }
    }

    jacoco {
        toolVersion = "0.8.8"
    }

    group = 'io.crate'

    tasks.withType(Javadoc) {
        failOnError = false
    }

    tasks.withType(Test) {
        doFirst {
            // move lucene-test-framework to the beginning of the classpath
            // for cli ./gradlew use
            def cp = project.sourceSets.test.runtimeClasspath
            def testFrameworkEntry = cp.find({ it.name.contains("lucene-test-framework") })
            if (testFrameworkEntry != null) {
                project.sourceSets.test.runtimeClasspath = files(testFrameworkEntry) + cp.filter({
                    !it.name.contains("lucene-test-framework")
                })
            }
        }
    }

}

clean {
    doLast {
        delete project.buildDir
    }
}

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

    project.ext {
        isEclipse = (System.getProperty("eclipse.launcher") != null
            || System.getProperty("eclipse.application") != 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')
                || gradle.startParameter.taskNames.contains('cleanIdeaBuild'))
    }

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

    if (isEclipse) {
        project.buildDir = file('build-eclipse')
    }

    if (it.name != 'es') {
        task cleanIdeaBuild {
            doLast {
                tasks.clean.execute()
            }
        }
    }
}

final testLogger = new TestLogger()
project.gradle.addListener(testLogger)


task jacocoReport(type: JacocoReport) {
    // tests must have been executed so that execution data for the sub projects is generated
    // this task doesn't define a hard dependency on the tests to avoid running them twice in travis-ci
    executionData fileTree(project.rootDir.absolutePath).include('**/build/jacoco/*.exec')

    subprojects.each {
        evaluationDependsOn(it.path)
        if (it.plugins.withType(JavaPlugin) && it.tasks.withType(Test)) {
            sourceSets it.sourceSets.main
            dependsOn << it.tasks.withType(Test)
        }
    }

    reports {
        xml {
            required = true
            destination file(project.buildDir.path + '/reports/jacoco/test/jacocoTestReport.xml')
        }
        csv.required = false
        html {
            required = true
            destination file(project.buildDir.path + '/reports/jacoco/jacocoHtml')
        }
    }
}

subprojects {
    idea {
        module {
            iml {
                // ensure testing dependencies come before es dependencies
                // when calling tests from intellij
                withXml {
                    def node = it.asNode()

                    def testFramework = node.component.orderEntry.find {
                        it.@'type' == 'module-library' && it.library.CLASSES.root.find {
                            it.@'url'.contains('lucene-test-framework')
                        }
                    }
                    if (testFramework != null) {
                        println "moving test framework"
                        def parent = testFramework.parent()
                        def newNode = new Node(parent, testFramework.name(), testFramework.attributes(), testFramework.value())
                        parent.remove(testFramework)
                        parent.children().add(5, newNode)
                    }
                }
            }
        }
    }
}



def jvmTestFlags = ['-ea', "-Dproject_build_dir=$project.buildDir", '-Dproject_root=$PROJECT_DIR$']

idea {
    workspace {
        iws.withXml { xmlFile ->
            def runManager = xmlFile.asNode().component.find { it.@name == 'RunManager' }

            // enable assertions for junit tests
            def junitDefaults = runManager.configuration.find { it.@default == 'true' && it.@type == 'JUnit' }
            junitDefaults.option.find { it.@name == 'VM_PARAMETERS' }.replaceNode {
                option(name: 'VM_PARAMETERS', value: jvmTestFlags.join(' '))
            }

            // add Crate application configuration
            def crateApp = runManager.configuration.find { it.@name == 'Crate' && it.@type == 'Application' }
            if (crateApp == null) {
                runManager.append(new XmlParser().parse(file("idea/crateApp.xml")))
            }
        }
    }

    project {
        vcs = 'Git'

        ipr {
            withXml { provider ->
                def node = provider.asNode()
                node.append(new XmlParser().parse(file("idea/codeStyle.xml")))
                node.append(new XmlParser().parse(file("idea/codeInspection.xml")))
                def copyrightManager = node.component.find { it.'@name' == 'CopyrightManager' }
                copyrightManager.@default = "CrateASL2"
                def aslCopyright = copyrightManager.copyright.find {
                    it.option.find { it.@name == "myName" }?.@value == "CrateASL2"
                }
                if (aslCopyright == null) {
                    copyrightManager.append(new XmlParser().parse(file("idea/copyright.xml")))
                }
            }
        }
    }
}

task generateLicenseNotes() {
    // Generate report about the licenses of the dependencies.
    // This task is an improved variant of the vanilla "generateLicenseReport".
    //
    // For invoking it, run::
    //
    //     ./gradlew generateLicenseNotes
    //
    // https://github.com/jk1/Gradle-License-Report

    licenseReport {
        outputDir = "${project.rootDir}/buildSrc/build/reports/licenses"
        renderers = [new InventoryMarkdownReportRenderer("3RD-PARTY-NOTICES.md")]
        filters = [new LicenseBundleNormalizer()]
        excludeGroups = ["org.openjdk.jmh"]
    }

    task createReport(type: Copy) {

        dependsOn "generateLicenseReport"

        from "${project.rootDir}/buildSrc/build/reports/licenses/3RD-PARTY-NOTICES.md"
        into "${project.rootDir}"
    }

    dependsOn "createReport"
}

wrapper {
    gradleVersion = '7.4.1'
}