build.gradle

allprojects {
    apply plugin: 'idea'

    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
        maven { url 'http://packages.confluent.io/maven/' }
    }
}

project.ext {
    apacheHttpClientVersion = "4.5.6"
    commonsCliVersion = '1.4'
    h2Version = '1.3.175'
    hamcrestVersion = '1.3'
    junitVersion = '4.11'
    mariadbDriverVersion = '2.4.2'
    nettyVersion = '4.1.44.Final'
    slf4jVersion = '1.7.25'
    mockitoVersion = '1.9.5'
    assertjVersion = '3.8.0'
    zkToolsVersion = '0.7.3'
    yamlVersion = '1.20'
    riffVersion = '2.5.2'
    jacksonVersion = '2.9.6'
    jettyVersion = '9.4.12.v20180830'
    mainClass = 'Main'
    buildVersionFileName = "waltz-version.properties"
}

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

    dependencies {
        classpath 'org.jfrog.buildinfo:build-info-extractor-gradle:3.1.1'
        classpath "com.github.jengelman.gradle.plugins:shadow:5.1.0"
        classpath 'se.transmode.gradle:gradle-docker:1.2'
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'checkstyle'
    apply plugin: 'findbugs'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    configurations.all {
        resolutionStrategy {
            force "org.hamcrest:hamcrest-all:$hamcrestVersion"
        }
    }

    jar {
        manifest {
            attributes(
                "Implementation-Title": "Waltz",
                "Implementation-Version": version)
        }
    }

    compileJava {
        sourceCompatibility = '1.8'
        targetCompatibility = '1.8'
    }

    compileTestJava {
        sourceCompatibility = '1.8'
        targetCompatibility = '1.8'
    }

    checkstyle {
        toolVersion = "8.10"
    }

    checkstyleTest {
        configFile = project.file ("${rootProject.projectDir}/config/checkstyle/checkstyle_test.xml")
    }

    // findbugs html only report
    findbugsMain {
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    findbugsTest {
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    task sourcesJar(type: Jar) {
        from sourceSets.main.allJava
        archiveClassifier = 'sources'
    }

    task javadocJar(type: Jar) {
        from javadoc
        archiveClassifier = 'javadoc'
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifactId = project.name

                from components.java
                artifact sourcesJar
                artifact javadocJar

                pom {
                    name = 'Waltz'
                    description = 'Waltz is a distributed/replicated write ahead log for transactions.'
                    url = 'https://www.github.com/wepay/waltz'
                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    developers {
                        developer {
                            id = 'ymatsuda'
                            name = 'Yasuhiro Matsuda'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/wepay/waltz.git'
                        developerConnection = 'scm:git:ssh://github.com/wepay/waltz.git'
                        url = 'https://github.com/wepay/waltz'
                    }
                }
            }
        }
        repositories {
            maven {
                def releasesRepoUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2'
                def snapshotsRepoUrl = 'https://oss.sonatype.org/content/repositories/snapshots'
                url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
                credentials {
                    username findProperty('ossrhUsername')?: ''
                    password findProperty('ossrhPassword')?: ''
                }
            }
        }
    }

    signing {
        sign publishing.publications.mavenJava
    }

    task execute(type:JavaExec) {
        main = mainClass
        classpath = sourceSets.main.runtimeClasspath
        if (project.hasProperty("commandArgs")) {
            args commandArgs.split()
        }
        standardInput = System.in
    }
}

project(':waltz-tools') {
    dependencies {
        compile (
            project(':waltz-client'),
            project(':waltz-server'),
            project(':waltz-storage'),

            "org.apache.httpcomponents:fluent-hc:$apacheHttpClientVersion"
        )

        testCompile (
            // TODO remove cyclic dependency
            // Not super thrilled about this, as it creates a circular dependency between
            // watlz-util and waltz-test. waltz-tools needs ZK server runner for tests, and
            // waltz-test needs to be able to create clusters to run smoke test and demo.
            project(':waltz-test'),

            "junit:junit:$junitVersion",
            "org.mockito:mockito-all:$mockitoVersion"
        )
    }

    task copyLibs(type:Copy) {
        into file("$projectDir/build/libs")
        from sourceSets.main.runtimeClasspath
    }

    test {
        maxHeapSize = "2G"
        jvmArgs '-Xmx2G'
    }
}

project(':waltz-server') {
    apply plugin: 'application'
    apply plugin: 'docker'

    dependencies {
        compile (
            project(':waltz-common'),
            project(':waltz-storage'),

            "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion",
            "com.wepay.riff:riff-config:$riffVersion",
            "com.wepay.riff:riff-metrics:$riffVersion",
            "com.wepay.zktools:zktools:$zkToolsVersion",
            "io.netty:netty-all:$nettyVersion",
            "org.slf4j:slf4j-api:$slf4jVersion",
            "org.eclipse.jetty:jetty-server:$jettyVersion",
            "org.eclipse.jetty:jetty-servlet:$jettyVersion",
        )

        testCompile (
            project(':waltz-client'),
            project(':waltz-test'),

            "junit:junit:$junitVersion",
            "org.mockito:mockito-all:$mockitoVersion"
        )
    }

    task createVersionFile {
        Object receiptFile = file("$buildDir/waltz/$buildVersionFileName")
        outputs.file receiptFile
        outputs.upToDateWhen { false }
        doLast {
            def data = [
                    version: version,
            ]

            receiptFile.parentFile.mkdirs()
            def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
            receiptFile.setText(content, "ISO-8859-1")
        }
    }

    jar {
        dependsOn createVersionFile
        from("$buildDir") {
            include "waltz/$buildVersionFileName"
        }
    }

    test {
        maxHeapSize = "2G"
        jvmArgs '-Xmx2G'
    }

    distDocker {
        mainClassName = 'com.wepay.waltz.server.WaltzServer'
        workingDir "${rootProject.name}-${project.version}"
    }
}

project(':waltz-storage') {
    apply plugin: 'application'
    apply plugin: 'docker'

    dependencies {
        compile (
            project(':waltz-common'),

            "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion",
            "com.wepay.riff:riff-config:$riffVersion",
            "com.wepay.riff:riff-metrics:$riffVersion",
            "com.wepay.zktools:zktools:$zkToolsVersion",
            "io.netty:netty-all:$nettyVersion",
            "org.slf4j:slf4j-api:$slf4jVersion",
            "org.yaml:snakeyaml:$yamlVersion",
            "org.eclipse.jetty:jetty-server:$jettyVersion",
            "org.eclipse.jetty:jetty-servlet:$jettyVersion",
        )

        testCompile (
            project(':waltz-test'),

            "junit:junit:$junitVersion",
            "org.mockito:mockito-all:$mockitoVersion"
        )
    }

    task createVersionFile {
        Object receiptFile = file("$buildDir/waltz/$buildVersionFileName")
        outputs.file receiptFile
        outputs.upToDateWhen { false }
        doLast {
            def data = [
                    version: version,
            ]

            receiptFile.parentFile.mkdirs()
            def content = data.entrySet().collect { "$it.key=$it.value" }.sort().join("\n")
            receiptFile.setText(content, "ISO-8859-1")
        }
    }

    jar {
        dependsOn createVersionFile
        from("$buildDir") {
            include "waltz/$buildVersionFileName"
        }
    }

    distDocker {
        mainClassName = 'com.wepay.waltz.storage.WaltzStorage'
        workingDir "${rootProject.name}-${project.version}"
        runCommand 'mkdir /waltz_storage'
    }
}

project(':waltz-uber') {
    apply plugin: "com.github.johnrengelman.shadow"

    dependencies {
        compile(
            project(':waltz-server'),
            project(':waltz-tools')
        )

        testCompile (
            project(':waltz-server')
        )

        runtime (
            "org.slf4j:slf4j-log4j12:$slf4jVersion"
        )
    }

    tasks.build.dependsOn tasks.shadowJar
    tasks.publish.dependsOn tasks.shadowJar

    publishing {
        publications {
            shadow(MavenPublication) { publication ->
                project.shadow.component(publication)

                pom {
                    name = 'Waltz'
                    description = 'Waltz is a distributed/replicated write ahead log for transactions.'
                    url = 'https://www.github.com/wepay/waltz'
                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    developers {
                        developer {
                            id = 'ymatsuda'
                            name = 'Yasuhiro Matsuda'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/wepay/waltz.git'
                        developerConnection = 'scm:git:ssh://github.com/wepay/waltz.git'
                        url = 'https://github.com/wepay/waltz'
                    }
                }
            }
        }
    }

    signing {
        sign publishing.publications.shadow
    }
}

project(':waltz-client') {
    dependencies {
        compile (
            project(':waltz-common'),

            "com.wepay.riff:riff-config:$riffVersion",
            "com.wepay.zktools:zktools:$zkToolsVersion",
            "io.netty:netty-all:$nettyVersion",
            "org.slf4j:slf4j-api:$slf4jVersion"
        )

        testCompile (
            project(':waltz-test'),

            "com.h2database:h2:$h2Version",
            "junit:junit:$junitVersion"
        )
    }
}

project(':waltz-common') {
    dependencies {
        compile (
            "com.wepay.riff:riff-config:$riffVersion",
            "com.wepay.riff:riff-metrics:$riffVersion",
            "com.wepay.riff:riff-networking:$riffVersion",
            "com.wepay.zktools:zktools:$zkToolsVersion",
            "commons-cli:commons-cli:$commonsCliVersion",
            "io.netty:netty-all:$nettyVersion",
            "org.slf4j:slf4j-api:$slf4jVersion",
            "org.yaml:snakeyaml:$yamlVersion"
        )

        testCompile (
            project(':waltz-test'),

            "junit:junit:$junitVersion",
            "org.assertj:assertj-core:$assertjVersion",
            "org.mockito:mockito-all:$mockitoVersion"
        )
    }
}

project(':waltz-test') {
    dependencies {
        compile (
            project(':waltz-server'),
            project(':waltz-client'),
            project(':waltz-storage'),
            project(':waltz-tools'),

            "junit:junit:$junitVersion",
            "com.wepay.zktools:zktools:$zkToolsVersion",
            "io.netty:netty-all:$nettyVersion"
        )

        testCompile (
            "junit:junit:$junitVersion"
        )
    }

    task copyLibs(type:Copy) {
        into file("$projectDir/build/libs")
        from sourceSets.main.runtimeClasspath
    }
}

project(':waltz-demo') {
    apply plugin: "com.github.johnrengelman.shadow"

    dependencies {
        compile (
            project(':waltz-server'),
            project(':waltz-client'),
            project(':waltz-test'),
            project(':waltz-tools'),

            "org.mariadb.jdbc:mariadb-java-client:$mariadbDriverVersion"
        )

        testCompile (
            "com.h2database:h2:$h2Version",
            "junit:junit:$junitVersion"
        )
    }

    tasks.build.dependsOn tasks.shadowJar
    tasks.publish.dependsOn tasks.shadowJar

    publishing {
        publications {
            shadow(MavenPublication) { publication ->
                project.shadow.component(publication)

                pom {
                    name = 'Waltz'
                    description = 'Waltz is a distributed/replicated write ahead log for transactions.'
                    url = 'https://www.github.com/wepay/waltz'
                    licenses {
                        license {
                            name = 'The Apache License, Version 2.0'
                            url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        }
                    }
                    developers {
                        developer {
                            id = 'ymatsuda'
                            name = 'Yasuhiro Matsuda'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/wepay/waltz.git'
                        developerConnection = 'scm:git:ssh://github.com/wepay/waltz.git'
                        url = 'https://github.com/wepay/waltz'
                    }
                }
            }
        }
    }

    signing {
        sign publishing.publications.shadow
    }
}