build.gradle

buildscript {
    ext.kotlin_version = "1.3.50"
    ext.jcommander_version = "1.72"
    ext.docker_compose_version = "0.9.4"

    repositories {
        mavenCentral()
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath 'com.github.jengelman.gradle.plugins:shadow:5.1.0'
        classpath "com.netflix.nebula:gradle-ospackage-plugin:6.2.1"
        classpath "com.avast.gradle:gradle-docker-compose-plugin:$docker_compose_version"
    }
}

plugins {
    id 'com.bmuschko.docker-remote-api' version "5.0.0"
}

// Apply the java plugin to add support for Java
apply plugin: 'idea'
apply plugin: 'java'
apply plugin: 'kotlin'
apply plugin: 'application'
apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: "nebula.ospackage"
apply plugin: 'nebula.ospackage-application'

group 'com.thelastpickle'
version '0.9-SNAPSHOT'
sourceCompatibility = 1.8

ext {
    log4j_api_version = "1.0.0"
    log4j_core_version = "2.17.1"
    slf4j_version = "2.16.0"
    jackson_dataformat_version = "2.9.0"
    jackson_kotlin_version = "2.9.+"
    jupiter_version = '5.5.2'
    assertj_version = '3.11.1'
}


application {
    applicationName = "tlp-cluster"
    mainClassName = "com.thelastpickle.tlpcluster.MainKt"
}

// In this section you declare where to find the dependencies of your project
allprojects {
    repositories {
        mavenCentral()
        jcenter()
    }
}


// In this section you declare the dependencies for your production and test code
dependencies {

    compile "org.apache.logging.log4j:log4j-api-kotlin:$log4j_api_version"
    compile "org.apache.logging.log4j:log4j-core:$log4j_core_version"
    compile group: "org.apache.logging.log4j", name: "log4j-slf4j18-impl", version: slf4j_version

    // https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-stdlib
    compile group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: kotlin_version

    compile group: 'com.beust', name: 'jcommander', version: jcommander_version
    compile 'com.google.guava:guava:27.0-jre'

    // for finding resources
    // https://mvnrepository.com/artifact/org.reflections/reflections
    compile group: 'org.reflections', name: 'reflections', version: '0.9.11'

    // https://mvnrepository.com/artifact/commons-io/commons-io
    compile group: 'commons-io', name: 'commons-io', version: '2.6'

    // https://mvnrepository.com/artifact/com.github.docker-java/docker-java
    compile group: 'com.github.docker-java', name: 'docker-java', version: '3.1.2'

    compile group: 'software.amazon.awssdk', name: 'ec2', version: '2.5.8'

    compile group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-yaml', version: jackson_dataformat_version
    compile group: 'com.fasterxml.jackson.module', name:'jackson-module-kotlin', version: jackson_kotlin_version


    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: jupiter_version

    // https://mvnrepository.com/artifact/org.assertj/assertj-core
    testCompile group: 'org.assertj', name: 'assertj-core', version: assertj_version

    compile 'com.github.ajalt:mordant:1.2.1'

    testCompile "io.mockk:mockk:1.9.3"

    implementation project(":core")
    implementation project(":aws-import")
}

build.dependsOn(":docker-pssh:buildDocker")

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
    kotlinOptions.freeCompilerArgs = ["-Xallow-result-return-type"]


}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
    kotlinOptions.freeCompilerArgs = ["-Xallow-result-return-type"]
}


sourceSets {
    main.java.srcDirs += "src/main/kotlin"
    test.java.srcDirs += "src/test/kotlin"
    main.resources.srcDirs += "build/aws"
}

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



configurations {
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntime.extendsFrom testRuntime
}

task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    outputs.upToDateWhen { false }
    description = "Runs the full end to end tests.  Will create a cluster in AWS.  Errors might require manual cluster tear down."
    group = "Verification"
}

test {
    useJUnitPlatform()
    reports {
        junitXml.enabled = true
        html.enabled = true
    }
}

buildRpm {
    requires("java-1.8.0-openjdk")
    user "root"
    group = "build"
}


ospackage {
    os = LINUX
    from(projectDir.toString() + '/bin') {
        into '/opt/tlp-cluster/bin'
        exclude 'tlp-cluster'
        fileMode = 0755
    }

    link("/usr/local/bin/tlp-cluster", "/opt/tlp-cluster/bin/tlp-cluster" )
    link("/usr/local/bin/build_cluster.sh", "/opt/tlp-cluster/bin/build_cluster.sh" )
    link("/usr/local/bin/install_reaper.sh", "/opt/tlp-cluster/bin/install_reaper.sh" )
    link("/usr/local/bin/install_medusa.sh", "/opt/tlp-cluster/bin/install_medusa.sh" )
    link("/usr/local/bin/build-cluster", "/opt/tlp-cluster/bin/build-cluster" )
    packager "OSC"
    maintainer "OSC"
    vendor "Datastax"
    url "http://thelastpickle.com/tlp-cluster/"
    license "Apache License 2.0"
    description "Cluster Experimentation Tool for Apache Cassandra by Datastax"
}

buildDeb {
    distribution "weezy,bionic,xenial,jessie"
    requires("openjdk-8-jre")
}

def buildDir = project.projectDir.toString() + '/build/distributions'

def cloudsmithApi = [
        'docker',
        'run',
        '-e', 'CLOUDSMITH_API_KEY=' + System.getenv("CLOUDSMITH_API_KEY"),
        '-v', buildDir + ":/build",
        'luigidifraia/cloudsmithcli:v1.0.4'
]

task uploadDeb(type: Exec) {
    group = "Publish"
    workingDir 'build/distributions'

    def debPackage = "tlp-cluster_${version}_all.deb"

    // get the deb package

    logger.info("Uploading DEB $debPackage")

    def pushDeb = cloudsmithApi + [
            'push',
            'deb',
            'thelastpickle/tlp-cluster/any-distro/any-version',
            '/build/' + debPackage
    ]
    commandLine(pushDeb)
}

task uploadRpm(type: Exec) {
    group = "Publish"
    workingDir 'build/distributions'

    def rpmPackage = "tlp-cluster-${version}.noarch.rpm"

    def pushRpm = cloudsmithApi + [
            'push',
            'rpm',
            'thelastpickle/tlp-cluster/any-distro/any-version',
            '/build/' + rpmPackage
    ]

    logger.info("Uploading RPM $rpmPackage")
    commandLine(pushRpm)
}

task uploadTar(type:Exec) {
    group = "Publish"
    workingDir 'build/distributions'
    def tarball = "tlp-cluster-${version}.tar"

    def pushTar = cloudsmithApi + [
            'push',
            'raw',
            'thelastpickle/tlp-cluster',
            '/build/' + tarball
    ]

    logger.info("Uploading Tar $tarball")
    commandLine(pushTar)
}

task buildAll {
    group = "Publish"
    dependsOn "buildDeb"
    dependsOn "buildRpm"
    dependsOn "distTar"
}

task uploadAll  {
    group = "Publish"
    dependsOn "uploadDeb"
    dependsOn "uploadRpm"
    dependsOn "uploadTar"
}


assemble.mustRunAfter clean

evaluationDependsOn(":aws-import")
task copyRegion(type: Copy, dependsOn: ':aws-import:generateRegionYaml') {
    from tasks.getByPath("aws-import:generateRegionYaml").outputs
    into "build/aws/com/thelastpickle/tlpcluster/ubuntu"
}

/*
 * This forces the CopyTask copyRegion to run before we compile any of the main sources
 * Without it, we won't be able to pull the region yaml into the main JAR and we can't pick the right AMI for a region
 */
compileKotlin.dependsOn(copyRegion)

build {
    dependsOn(":docker-cassandra-build:buildDocker")
    dependsOn(":docker-pssh:buildDocker")

}