build.gradle

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

plugins {
    id 'me.champeau.gradle.jmh' version '0.2.0'
}


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;
}

ext {
    versions = [
            // update this value when elasticsearch is updated
            elasticsearch: "2.3.4"
    ]
}

repositories {
    mavenCentral()
}

allprojects {
    apply plugin: 'findbugs'
    apply plugin: 'jacoco'

    configurations.all {
        resolutionStrategy {
            // fail eagerly on version conflict (includes transitive dependencies)
            failOnVersionConflict()

            // ES requires hamcrest-all which includes hamcrest-core
            dependencySubstitution {
                substitute module('org.hamcrest:hamcrest-core') with(
                        module('org.hamcrest:hamcrest-all:1.3'))
            }

            // forced versions of conflicting deps
            force 'com.spatial4j:spatial4j:0.5'
            force 'com.google.guava:guava:18.0'
            force 'commons-codec:commons-codec:1.10'
            force 'com.carrotsearch.randomizedtesting:junit4-ant:2.3.1'
            force 'com.carrotsearch.randomizedtesting:randomizedtesting-runner:2.3.1'
            force 'junit:junit:4.11'
            force 'org.slf4j:slf4j-api:1.6.2'
            force 'com.fasterxml.jackson.core:jackson-core:2.6.2'
            force 'joda-time:joda-time:2.8.2'
            force 'org.hamcrest:hamcrest-all:1.3'
            force 'org.antlr:antlr-runtime:3.5.2'
            force 'commons-cli:commons-cli:1.3.1'
            force 'org.apache.commons:commons-math3:3.4.1'
            force 'org.apache.commons:commons-lang3:3.3.2'
            force 'commons-logging:commons-logging:1.1.3'
            force 'org.apache.httpcomponents:httpcore:4.3.3'
            force 'org.apache.httpcomponents:httpclient:4.3.6'
            force 'org.slf4j:slf4j-log4j12:1.7.10'
            force 'log4j:log4j:1.2.17'
            force 'io.netty:netty:3.10.5.Final'

            // ensure to check following dependencies and their versions against those of HDFS plugin libs
            // https://crate.io/docs/reference/en/latest/sql/snapshot_restore.html
            force 'org.codehaus.jackson:jackson-core-asl:1.9.13'
            force 'org.codehaus.jackson:jackson-mapper-asl:1.9.13'
            force 'com.google.code.findbugs:jsr305:3.0.1'
            force 'commons-lang:commons-lang:2.6'
        }
    }

    tasks.withType(JavaCompile) {
        sourceCompatibility = "1.7"
        targetCompatibility = "1.7"
        options.encoding = 'UTF-8'
    }

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

        // allow to set the number of test forks from the CLI
        if (project.hasProperty('testForks')) {
            maxParallelForks = project.testForks 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"
    }

    jacoco {
        toolVersion = "0.7.1.201405082137"
    }

    group = 'io.crate'

    findbugs {
        ignoreFailures = true
    }

    // if environment variable JAVA7_HOME is set, add it to bootClasspath
    // for compiling for java 7 compatibility using javac from jdk8
    tasks.withType(JavaCompile) {
        doFirst {
            if (sourceCompatibility == '1.7' && System.env.JAVA7_HOME != null) {
                options.fork = true
                options.bootClasspath = "$System.env.JAVA7_HOME/jre/lib/rt.jar"
            }
        }
    }

    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")
                })
            }
        }
    }

}

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

    project.ext {
        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')
        }
    }

    task cleanIdeaBuild << {
        tasks.clean.execute()
    }
}

final testOutputs = [:].withDefault { [] }


project.gradle.addListener(new TestOutputListener() {
    @Override
    void onOutput(TestDescriptor test, TestOutputEvent outputEvent) {
        testOutputs[test] << outputEvent.getMessage()
    }
})

project.gradle.addListener(new TestListener() {

    @Override
    void beforeSuite(TestDescriptor suite) {
        logger.lifecycle('Running: ' + suite)
    }

    @Override
    void afterSuite(TestDescriptor suite, TestResult result) {
    }

    @Override
    void beforeTest(TestDescriptor test) {
    }

    @Override
    void afterTest(TestDescriptor test, TestResult result) {
        if (result.getResultType() == TestResult.ResultType.FAILURE) {
            logger.error('## FAILURE: ' + test)
            testOutputs[test].each { e ->
                print e
            }
        }
        testOutputs.remove(test)
    }
})


def jacocoProjects() {
    subprojects.findAll {
        it.name != 'es' && it.name != 'testing'
    }
}


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')

    jacocoProjects().each {
        evaluationDependsOn(it.name)
        if (it.plugins.withType(JavaPlugin) && it.tasks.withType(Test)) {
            sourceSets it.sourceSets.main
        }
    }

    reports {
        xml {
            enabled true
            destination "${buildDir}/reports/jacoco/test/jacocoTestReport.xml"
        }
        csv.enabled false
        html {
            enabled true
            destination "${buildDir}/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")))
                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 wrapper(type: Wrapper) {
    gradleVersion = '3.1'
}