build.gradle

import java.util.concurrent.TimeUnit

apply plugin: 'java'
apply plugin: 'groovy'
apply plugin: 'eclipse'
apply plugin: 'application'
apply plugin: 'spring-boot'
apply plugin: "jacoco"
apply plugin: 'findbugs'
// if this is applied, include scala dependencies (see below)
// apply plugin: 'scala'

group 'de.zalando.aruha'
sourceCompatibility = 1.8
targetCompatibility = 1.8

mainClassName = 'de.zalando.aruha.nakadi.Application'
def dockerGroup = "aruha"
def dockerApplicationName = "nakadi"
def dockerContainerName = "nakadi-local"

def storagesContainerName = "local-storages"

/* config parameters */
def dockerImageName = "$dockerGroup/$dockerApplicationName"
if (project.hasProperty("dockerImageName")) {
    dockerImageName = project.property("dockerImageName")
}
def dockerImageVersion = "AUTOBUILD"
if (project.hasProperty("dockerImageVersion")) {
    dockerImageVersion = project.property("dockerImageVersion")
}
def dockerImageTag = "$dockerImageName:$dockerImageVersion"


def dockerBuildTimeout = 300

def loadYaml() {
    org.yaml.snakeyaml.DumperOptions options = new org.yaml.snakeyaml.DumperOptions();
    options.setDefaultFlowStyle(org.yaml.snakeyaml.DumperOptions.FlowStyle.BLOCK);
    def yaml = new org.yaml.snakeyaml.Yaml(options)
    def file = new File("src/main/resources/application.yml").text
    def cfg = (Map) yaml.load(file)
    return cfg
}

def application_config = loadYaml()

repositories {
    mavenCentral()
}

sourceSets {
    integrationTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/java')
        }
        resources.srcDir file('src/integration-test/resources')
    }

    acceptanceTest {
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/acceptance-test/java')
        }
        resources.srcDir file('src/acceptance-test/resources')
    }
}

buildscript {
    repositories {
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:1.2.5.RELEASE"
        classpath 'org.yaml:snakeyaml:1.14'
    }
}

jar {
    baseName = 'nakadi'
}

configurations {
    all*.exclude module : 'spring-boot-starter-logging'
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntime.extendsFrom testRuntime
    acceptanceTestCompile.extendsFrom testCompile
    acceptanceTestRuntime.extendsFrom testRuntime
    pgsql
}

findbugs {
    reportLevel = "high"
    sourceSets = []
}

dependencies {
    ext {
        dropwizardVersion = '3.1.2'
    }

    pgsql 'org.postgresql:postgresql:9.4.1207'
    // spring
    compile('org.springframework.boot:spring-boot-starter-web:1.3.1.RELEASE') {
        exclude module: 'logback-classic'
        exclude module: 'log4j-over-slf4j'
    }
    compile 'org.springframework:spring-context:4.2.0.RELEASE'
    compile 'org.springframework:spring-web:4.2.0.RELEASE'
    compile 'org.springframework:spring-webmvc:4.2.0.RELEASE'

    // oauth
    compile 'org.springframework.security.oauth:spring-security-oauth2:2.0.8.RELEASE'
    compile('org.springframework.boot:spring-boot-starter-security') {
        exclude module: "logback-classic"
    }

    // storage
    compile 'org.springframework.boot:spring-boot-starter-jdbc:1.3.1.RELEASE'
    compile 'org.postgresql:postgresql:9.4.1207'

    // misc
    compile 'org.apache.httpcomponents:httpclient:4.5.1'
    compile ('org.zalando.stups:stups-spring-oauth2-server:1.0.10') {
        exclude module: "httpclient"
    }
    compile 'org.zalando:jackson-datatype-problem:0.5.0'
    compile 'org.zalando:problem:0.5.0'
    compile 'org.zalando:problem-spring-web:0.5.0'
    compile 'com.google.guava:guava:19.0'
    compile 'joda-time:joda-time:2.2'
    compile 'javax.ws.rs:javax.ws.rs-api:2.0.1'
    compile 'org.slf4j:slf4j-log4j12:1.7.14'
    compile "io.dropwizard.metrics:metrics-core:$dropwizardVersion"
    compile "com.ryantenney.metrics:metrics-spring:$dropwizardVersion"
    compile "io.dropwizard.metrics:metrics-servlets:$dropwizardVersion"
    compile "io.dropwizard.metrics:metrics-jvm:$dropwizardVersion"
    compile 'org.apache.commons:commons-lang3:3.4'
    compile 'org.zalando:problem-spring-web:0.5.0'
    compile 'org.zalando:jackson-datatype-problem:0.5.0'

    // kafka & zookeeper
    compile 'org.apache.kafka:kafka-clients:0.9.0.0'
    compile 'org.apache.kafka:kafka_2.11:0.9.0.0'
    compile 'org.apache.curator:curator-framework:2.9.1'
    compile 'org.apache.curator:curator-recipes:2.9.1'

    // json
    compile 'org.everit.json:org.everit.json.schema:1.2.0'
    compile ('com.fasterxml.jackson.datatype:jackson-datatype-json-org:2.4.0') {
        exclude module: "json"
    }

    // scala dependencies
    //compile 'org.scala-lang:scala-library:2.11.6'
    //testCompile 'org.scalatest:scalatest_2.11:2.2.4'

    // tests
    testCompile 'org.hamcrest:hamcrest-all:1.3'
    testCompile('junit:junit:4.12') {
        exclude module: "hamcrest-core"
    }
    testCompile 'org.springframework.boot:spring-boot-starter-test'
    testCompile 'org.skyscreamer:jsonassert:1.3.0'
    testCompile 'uk.co.datumedge:hamcrest-json:0.2'
    testCompile 'org.mockito:mockito-all:1.10.19'
    testCompile('com.jayway.restassured:rest-assured:2.5.0') {
        exclude module: "hamcrest-core"
        exclude module: "hamcrest-library"
    }
    testCompile 'com.jayway.jsonpath:json-path:2.2.0'
    testCompile 'org.echocat.jomon:runtime:1.6.2'
    testRuntime 'org.pegdown:pegdown:1.1.0'
}
// end::dependencies[]

// tag::wrapper[]
task wrapper(type: Wrapper) {
    gradleVersion = '2.3'
}

tasks.withType(FindBugs) {
    reports {
        xml.enabled = false
        html.enabled = true
    }
}

task cleanDb << {
    def sql = getSqlInstance(application_config["spring"]["datasource"])

    sql.execute('TRUNCATE zn_data.event_type')

    sql.close()
}

task dbBootstrap << {
    def db = application_config["spring"]["datasource"]

    def sql = getSqlInstance(db)

    def sqlFileList = getSortedSqlFiles()

    sqlFileList.each {
        println 'Running script: ' + it
        String sqlString = it.text
        sql.execute(sqlString)
    }

    sql.execute("RESET ROLE")

    sql.execute("CREATE ROLE " + db['username'] + " WITH LOGIN PASSWORD '" + db['password'] + "'")

    sql.execute("GRANT zalando_nakadi_data_writer TO " + db['username'])

    sql.close()
}

def getSortedSqlFiles() {
    def sqlFileList = []
    new File('database').eachFileRecurse(groovy.io.FileType.FILES) {
        if (it.name.endsWith('.sql')) {
            sqlFileList << it
        }
    }

    sqlFileList.sort()
}

def getSqlInstance(db) {
    // This is needed to get postgreSQL driver onto the Groovy/Gradle classpath
    configurations.pgsql.each { file ->
        println "Adding URL: $file"
        gradle.class.classLoader.addURL(file.toURI().toURL())
    }

    groovy.sql.Sql.newInstance(db.url, 'nakadi', db.password, db.driverClassName)
}

def runMakeStorages(target, options="", timeout=15) {
    execAndWait("make " + options + " --directory local-storages " + target, timeout)
}

task stopAndRemoveStoragesInDocker {
    doLast {
        runMakeStorages("stop-and-remove", "", dockerBuildTimeout)
    }
    outputs.upToDateWhen { false }
}

task startStoragesInDockerBound() {
    finalizedBy dbBootstrap
    doLast {
        runMakeStorages("run", "PUBLISH_NAKADI_PORT=\"-p 8080:8080\"", dockerBuildTimeout)
    }
    outputs.upToDateWhen { false }
}

task startStoragesInDocker() {
    finalizedBy dbBootstrap
    doLast {
        runMakeStorages("run", "", dockerBuildTimeout)
    }
    outputs.upToDateWhen { false }
}

task generateScmSourceJson() {
    def rev = new ByteArrayOutputStream()
    exec {
        commandLine "git", "rev-parse", "HEAD"
        standardOutput = rev
    }
    rev = rev.toString().trim()

    def url = new ByteArrayOutputStream()
    exec {
        commandLine "git", "config", "--get", "remote.origin.url"
        standardOutput = url
    }
    url = url.toString().trim()

    def status = new ByteArrayOutputStream()
    exec {
        commandLine "git", "status", "--porcelain"
        standardOutput = status
    }
    status = status.toString().trim().replaceAll("[\n\r]", "\\\\n")
    if (status) {
        rev = "$rev (locally modified)"
    }
    def scmSource = new FileOutputStream("scm-source.json")
    scmSource.write("{\"url\": \"git:${url}\", \"revision\":\"${rev}\", \"author\": \"${System.getenv()['USER']}\", \"status\": \"${status}\"}".getBytes())
    scmSource.close()
}

task buildDockerImage {
    dependsOn bootRepackage, generateScmSourceJson
    doLast {
        println "Building docker image with tag: $dockerImageTag"
        if (execAndWait("docker build -t " + dockerImageTag + " .", dockerBuildTimeout) != 0) {
            throw new GradleException("docker build failed.")
        }
    }
    outputs.upToDateWhen { false }
}

task pushDockerImage {
    dependsOn buildDockerImage
    doLast {
        println "Pushing docker image with tag: $dockerImageTag"
        if (execAndWait("docker push " + dockerImageTag, dockerBuildTimeout) != 0) {
            throw new GradleException("docker push failed.")
        }
    }
}

task removeOldDockerContainer(type: Exec) {
    commandLine "bash", "-c",
            "for c in `docker ps -qaf name=$dockerContainerName`; do docker rm -f \$c; done"
}

task startDockerContainer(type: Exec) {
    commandLine "bash", "-c", "docker run -e \"NAKADI_OAUTH2_MODE=OFF\" " +
            "--net container:$storagesContainerName --name $dockerContainerName -i -t -d $dockerImageTag"
    dependsOn buildDockerImage, removeOldDockerContainer, startStoragesInDockerBound
}

task stopAndRemoveDockerContainer(type: Exec) {
    dependsOn stopAndRemoveStoragesInDocker
    commandLine "bash", "-c",
            "for c in `docker ps -qaf name=$dockerContainerName`; do docker rm -f \$c; done"
}

task integrationTest(type: Test) {
    testClassesDir = sourceSets.integrationTest.output.classesDir
    classpath = sourceSets.integrationTest.runtimeClasspath
}

task acceptanceTest(type: Test) {
    testClassesDir = sourceSets.acceptanceTest.output.classesDir
    classpath = sourceSets.acceptanceTest.runtimeClasspath
}

def execAndWait(command, timeoutInSeconds = 15) {
    println "Running command: " + command
    ProcessBuilder pb = new ProcessBuilder(["bash", "-c", command]).inheritIO();
    Process proc = pb.start();
    proc.waitFor(timeoutInSeconds, TimeUnit.SECONDS);
    return proc.exitValue()
}

task startDockerContainerAndWait() {
    // start app with docker
    dependsOn startDockerContainer

    doLast {
        // wait till application is up (health check is successful)
        int result = 1
        while (result != 0) {
            result = execAndWait('curl http://localhost:8080/health')
            sleep(1000L)
        }
    }
    outputs.upToDateWhen { false }
}

task fullAcceptanceTest(type: GradleBuild) {
    dependsOn startDockerContainerAndWait
    tasks = ['acceptanceTest']
    finalizedBy cleanDb, stopAndRemoveStoragesInDocker, stopAndRemoveDockerContainer
}

test {
    testLogging {
        events "passed", "skipped", "failed"
    }
}

integrationTest {
    testLogging {
        events "passed", "skipped", "failed"
    }
}

acceptanceTest {
    testLogging {
        events "passed", "skipped", "failed"
    }
}

task development << {
    jvmArgs = ["-Dnakadi.config=envs/development.conf"]
    //bootRun.systemProperty 'nakadi.config', 'envs/development.conf'
}

bootRun {
    addResources = false
    main = 'de.zalando.aruha.nakadi.Application'
    environment 'NAKADI_OAUTH2_MODE', 'OFF'
}

run {
}

jacocoTestReport {
    reports {
        xml.enabled = true
        html.enabled = true
    }
}

check.dependsOn jacocoTestReport
check.dependsOn integrationTest
integrationTest.mustRunAfter test