build.gradle

/*
 * Copyright 2017 Datamountaineer.
 *
 * Licensed 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.
 */


import de.undercouch.gradle.tasks.download.Download


plugins {
    id "de.undercouch.download" version "3.4.3"
    id "com.github.maiflai.scalatest" version "0.23"
    id "com.github.johnrengelman.shadow" version "4.0.3"
}


// gradle 3.0 intellj fixes
ScalaCompileOptions.metaClass.daemonServer = true
ScalaCompileOptions.metaClass.fork = true
ScalaCompileOptions.metaClass.useAnt = false
ScalaCompileOptions.metaClass.useCompileDaemon = false


allprojects {
    group = 'com.datamountaineer'
    version = project.version
    description = "stream-reactor"
    apply plugin: 'java'
    apply plugin: 'scala'
    apply plugin: 'maven'
    apply plugin: 'com.github.johnrengelman.shadow'
    apply plugin: 'de.undercouch.download'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'
    apply plugin: 'com.github.maiflai.scalatest'

    sourceCompatibility = 1.8
    targetCompatibility = 1.8
    

    ext {
        scalaMajorVersion = '2.11'
        scala = '2.11.7'
        scalaCheck = '1.13.4'
        scalaTest = '3.0.0'
        junit = '4.11'
        //avroVersion="1.8.1"
        scalaLoggingVersion = '2.1.2'
        mockitoVersion = '1.10.19'
        jacksonDatabind = '2.8.5'
        slf4jVersion = "1.7.7"
        json4sVersion = "3.5.3"
        gsonVersion = "2.6.2"
        KCQLVersion = "2.8.3"
        akkaVersion = "2.4.10"
        connectCLIVersion = "1.0.6"

        // The following 4 need to align to compile against a particular version
        confluentVersion = '5.0.0'
        kafkaVersion = '2.1.0'
        dataMountaineerCommonVersion = "1.1.7"
        link4jVersion = "1.8.0"

        gitCommitHash = ("git rev-parse HEAD").execute().text.trim()
        gitTag = ("git describe --abbrev=0 --tags").execute().text.trim()
        gitRepo = ("git remote get-url origin").execute().text.trim()


//        // The following 4 need to align to compile against a particular version
//        confluentVersion = '3.3.0'
//        kafkaVersion = '0.11.0.0'
//        dataMountaineerCommonVersion = "0.9.7"
//        dataMountaineerTestKitVersion = "0.6"

//        // Confluent 3.2
//        confluentVersion = '3.2.2'
//        kafkaVersion = '0.10.2.0'
//        dataMountaineerCommonVersion = "0.8.1.1"
//        dataMountaineerTestKitVersion = "0.5"

        // For 3.1.x versions use
        // confluentVersion = '3.1.2'
        // kafkaVersion = '0.10.1.1'
        // dataMountaineerCommonVersion = "0.7.0"
        // dataMountaineerTestKitVersion = "0.4"

        //release
        rootRelease = "${project.rootDir}/release/"
        versionDir = "${rootRelease}/${project.description}-${project.version}-${kafkaVersion}"
        confDir = "${versionDir}/conf"
        libsDir = "${versionDir}/libs"
        binDir = "${versionDir}/bin"
        tarName = "${project.description}-${project.version}-${kafkaVersion}.tar.gz"
        cliUrl = "https://github.com/landoop/kafka-connect-tools/releases/download/v${connectCLIVersion}/connect-cli"
        srCliUrlDarwin = "https://github.com/landoop/schema-registry/releases/download/0.0.1/sr-cli-osx"
        srCliUrlLinux = "https://github.com/landoop/schema-registry/releases/download/0.0.1/sr-cli-linux"
    }

    repositories {
        mavenLocal()
        mavenCentral()
        maven { url "http://packages.confluent.io/maven/" }
        maven { url "http://repo.typesafe.com/typesafe/releases/" }
        maven { url "https://repository.cloudera.com/artifactory/cloudera-repos/" }
        maven { url "http://conjars.org/repo" }
        //maven {
        //    url 'http://dl.bintray.com/andsel/maven/'
        //}
    }

    jar {
        manifest {
            attributes( "StreamReactor-Version": project.version,
                        "KCQL-Version" : "${KCQLVersion}",
                        "Kafka-Version": "${kafkaVersion}",
                        "Created-By" : "Landoop",
                        "Created-At" :  new Date().format("YYYYMMDDHHmm"),
                        "Git-Repo": "${gitRepo}",
                        "Git-Commit-Hash": "${gitCommitHash}",
                        "Git-Tag": "${gitTag}",
                        "StreamReactor-Docs" : "https://lenses.stream/"
            )
        }
    }

    shadowJar {
        configurations = [project.configurations.runtime]
        baseName = "${project.name}-${project.version}-${kafkaVersion}-all"
        classifier = null
        version = null

        zip64 true

        manifest {
            attributes( "StreamReactor-Version": project.version,
                    "KCQL-Version" : "${KCQLVersion}",
                    "Kafka-Version": "${kafkaVersion}",
                    "Created-By" : "Landoop",
                    "Created-At" : new Date().format("YYYYMMDDHHmm"),
                    "Git-Repo": "${gitRepo}",
                    "Git-Commit-Hash": "${gitCommitHash}",
                    "Git-Tag": "${gitTag}",
                    "StreamReactor-Docs" : "https://lenses.stream/"
            )
        }

        mergeServiceFiles {
            exclude "META-INF/*.SF"
            exclude "META-INF/*.DSA"
            exclude "META-INF/*.RSA"
        }

        transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer) {
            resource = 'reference.conf'
        }
        dependencies {
            exclude(dependency("org.apache.avro:.*"))
            exclude(dependency("org.apache.kafka:.*"))
            exclude(dependency("io.confluent:.*"))
            exclude(dependency("org.apache.kafka:.*"))
            exclude(dependency("org.apache.zookeeper:.*"))
        }
    }

    dependencies {
        compile "org.scala-lang:scala-library:$scala"
        compile "org.scala-lang:scala-compiler:$scala"
        compile "com.typesafe.scala-logging:scala-logging-slf4j_$scalaMajorVersion:$scalaLoggingVersion"

        compile ("org.apache.kafka:connect-json:$kafkaVersion")
        compile "io.confluent:kafka-connect-avro-converter:$confluentVersion"
        compile "io.confluent:kafka-schema-registry:$confluentVersion"

        compile("com.datamountaineer:kafka-connect-common:$dataMountaineerCommonVersion") {

        }
        compile "org.apache.calcite:calcite-linq4j:$link4jVersion"

        testCompile "org.mockito:mockito-core:$mockitoVersion"
        testCompile "org.scalacheck:scalacheck_$scalaMajorVersion:$scalaCheck"
        testCompile "org.scalatest:scalatest_$scalaMajorVersion:$scalaTest"
        testCompile "junit:junit:$junit"

        testRuntime 'org.pegdown:pegdown:1.1.0'
    }

    test {
        maxParallelForks = 1
        minHeapSize '256m'
        maxHeapSize '2048m'
    }

    task testJar(type: Jar, dependsOn: testClasses) {
        baseName = "test-${project.archivesBaseName}"
        from sourceSets.test.output
    }

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

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

    task scaladocJar(type: Jar) {
        classifier = 'scaladoc'
        from '../LICENSE'
        from scaladoc
    }

    tasks.withType(Tar) {
        compression Compression.GZIP
        extension = 'tgz'
    }

    task compile(dependsOn: 'compileScala')

    task fatJar(dependsOn: [test, shadowJar])

    task collectJars(type: Copy) {
        into "${buildDir}/libs-dependencies"
        from configurations.runtime
    }

    task collectFatJar(type: Copy, dependsOn: [fatJar]) {
        from "${buildDir}/libs"
        into libsDir
    }

    artifacts {
        archives javadocJar, scaladocJar, sourcesJar
    }

    if (project.hasProperty('release')) {
        signing {
            ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
            required { isReleaseVersion }
            // required { isReleaseVersion && gradle.taskGraph.hasTask("uploadArchives") }
            sign configurations.archives
        }
    }

    // OSSRH publication
    uploadArchives {
        repositories {
            mavenDeployer {
                // POM signature
                beforeDeployment { MavenDeployment deployment ->
                    signArchives
                    signing.signPom(deployment)
                }
                // Target repository
                repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                    authentication(userName: ossrhUsername, password: ossrhPassword)
                }
                pom.project {
                    name project.name
                    description project.description
                    packaging 'jar'
                    url 'https://github.com/landoop/stream-reactor'

                    scm {
                        connection 'scm:git:https://github.com/landoop/stream-reactor.git'
                        developerConnection 'scm:git:git@github.com:landoop/stream-reactor.git'
                        url 'https://github.com/landoop/stream-reactor.git'
                    }

                    licenses {
                        license {
                            name 'Apache License 2.0'
                            url 'http://www.apache.org/licenses/LICENSE-2.0.html'
                            distribution 'repo'
                        }
                    }

                    developers {
                        developer {
                            id = 'andrewstevenson'
                            name = 'Andrew Stevenson'
                            email = 'andrew@landoop.com'
                        }
                        developer {
                            id = 'stheppi'
                            name = 'Stefan Bocutiu'
                            email = 'stefan@landoop.com'
                        }
                        developer {
                            id = 'antwins'
                            name = 'Antonios Chalkiopoulos'
                            email = 'antonios@landoop.com'
                        }
                    }
                }
            }

        }
    }
}

task prepareReleaseDir(type: Copy) {
    doFirst {
        def root = new File(rootRelease)
        def version = new File(versionDir)
        def bin = new File(binDir)
        def libs = new File(libsDir)
        def conf = new File(confDir)

        root.deleteDir()
        root.mkdirs()
        version.mkdirs()
        libs.mkdirs()
        conf.mkdirs()
        bin.mkdirs()
    }
    from("${project.rootDir}") {
        include "README.md"
        include "LICENSE"
    }
    into versionDir
}

task downloadCli(type: Download, dependsOn: prepareReleaseDir) {
    overwrite false
    src cliUrl
    dest binDir
}

task downloadSchemaCli(type: Download, dependsOn: prepareReleaseDir) {
    overwrite false
    src([srCliUrlDarwin, srCliUrlLinux])
    dest binDir
}


task collectConfs(type: Copy, dependsOn: prepareReleaseDir) {
    from "${project.rootDir}/conf"
    into confDir
}

task collectBin(type: Copy, dependsOn: prepareReleaseDir) {
    from("${project.rootDir}/bin") {
        filter { it.replaceAll('@@CLI_VERSION@@', connectCLIVersion) }
        filter { it.replaceAll('@@STREAM_REACTOR_VERSION@@', "${project.version}-${kafkaVersion}") }
    }
    into binDir
}

task prepareRelease(dependsOn: [downloadCli, downloadSchemaCli, collectConfs, collectBin]) {
    dependsOn subprojects.collectFatJar

    doLast {
        exec {
            commandLine "chmod", "+x", "${binDir}/sr-cli-osx"
            commandLine "chmod", "+x", "${binDir}/sr-cli-linux"
        }
    }
}

task tar(type: Tar, dependsOn: prepareRelease) {
    from rootRelease
    exclude "**.gz"
    archiveName = tarName
    destinationDir = file(rootRelease)
    compression = Compression.GZIP
}

project.tasks.compileScala.scalaCompileOptions.additionalParameters = ["-target:jvm-1.8"]
project.tasks.compileTestScala.scalaCompileOptions.additionalParameters = ["-target:jvm-1.8"]