build.gradle

import org.apache.tools.ant.BuildException

apply plugin: 'java'
apply plugin: 'groovy'
apply plugin: 'scala'
apply plugin: 'eclipse'
apply plugin: 'idea'

apply plugin: 'checkstyle' //for java code conventions
apply plugin: 'jdepend' //for dependency analysis
apply plugin: 'findbugs' //for static code analysis
apply plugin: 'pmd'

idea {
    module {
       testSourceDirs += file('acceptance-tests/drivers/java/driver-version-2.11.3')
       testSourceDirs += file('acceptance-tests/journeys/scala')
    }
}
defaultTasks 'clean', 'build'

clean.dependsOn = ['killMidas']

sourceCompatibility = '1.7'
targetCompatibility = '1.7'

project.ext {
    //App Config
    appConfigUrl = new URL("file:///${projectDir}/AppConfig.groovy")
    appConfig = new ConfigSlurper('configuration').parse(appConfigUrl).configuration
    manifest = appConfig.product.distribution.jar.manifest.details
    project.archivesBaseName = appConfig.product.distribution.name
    previousArchiveName = appConfig.product.distribution.previousArchiveName

    //libs
    mongoDriver = 'org.mongodb:mongo-java-driver:2.11.3'
    groovy = 'org.codehaus.groovy:groovy-all:2.2.0'
    scala = 'org.scala-lang:scala-library:2.10.2'
    asm = 'org.ow2.asm:asm:4.1'
    junit = 'junit:junit:4.8.1'
    mockito = 'org.mockito:mockito-all:1.9.5'
    specs2 = 'org.specs2:specs2_2.10:2.2.2'
    //for acceptance-test reporting
    pegdown = 'org.pegdown:pegdown:1.2.1'
    spock = 'org.spockframework:spock-core:0.7-groovy-2.0'
    slf4j = 'org.slf4j:slf4j-api:1.7.5'
    log4jBinding = 'org.slf4j:slf4j-log4j12:1.7.5'
    cglib = 'cglib:cglib-nodep:2.2'
    scopt = 'com.github.scopt:scopt_2.10:3.2.0'
    disruptor = 'com.lmax:disruptor:3.0.0.beta1'

    //for scala style plugin
    scalaStyle = 'org.scalastyle:scalastyle_2.10:0.3.2'
    scalaStyleReportsDirName = "$reporting.baseDir/scalastyle"

    //code coverage lib
    coberturaCoverageReportsDirName = "$reporting.baseDir/cobertura"
    coberturaLineCoverageBaseline = 88
    coberturaBranchCoverageBaseline = 38.5 //reduced from 70

    //dependency analysis
    jdepend = 'jdepend:jdepend:2.9.1'

    //Distribution settings
    distsTemplateDir = 'distribution-template'
    distsBinDirName = "$project.distsDir/bin"
    distsZipFileName = "${project.distsDir}/${project.archivesBaseName}.zip"

    resourcesDir = 'src/main/resources'

    //Explode Distributables here
    explodedDir = "$project.buildDir/exploded"

    //Runtime Configurations
    DEFAULT_PORT_PREFIX = 270
    portPrefix = System.getProperty('mongoVersion', "$DEFAULT_PORT_PREFIX")

    DEFAULT_LANGUAGE = 'java'
    language = System.getProperty('language', "$DEFAULT_LANGUAGE")

    MIDAS_SERVER = 'localhost'
    midasServer = System.getProperty('midasServer', "$MIDAS_SERVER")

    MONGODB_SERVER = 'localhost'
    mongoDB = System.getProperty('mongoDB', "$MONGODB_SERVER")

    acceptanceTestDir = 'acceptance-tests'
    acceptanceTestReportsDir = "${reporting.baseDir}/acceptance-tests"
    smokeTestsDir = "smoke-tests"
    smokeTestReportsDir = "${reporting.baseDir}/${smokeTestsDir}"
    documentationDir = "distribution-template/documentation/"
    journeysDir = "${documentationDir}/journeys"

    javaAcceptanceTestDir = "$acceptanceTestDir/drivers/java/driver-version-2.11.3"
    javaAcceptanceTestReportsDir = "$acceptanceTestReportsDir/java"
    pythonAcceptanceTestDir = "$acceptanceTestDir/drivers/python/driver-version-2.6.3"
    pythonAcceptanceTestReportsDir = "$acceptanceTestReportsDir/python"

    acceptanceJourneyTestDir = "$acceptanceTestDir/journeys/scala"
    acceptanceJourneyTestReportsDir = "$acceptanceTestReportsDir/journeys"

    transformsPackage = 'com/ee/midas/transform/'
    deltas = "deltas"
    transformations = "generated"
    templates = "templates"
    transformationsDir = "${project.buildDir}/resources/main/$transformations"
    deltasDir = "${project.buildDir}/resources/main/$deltas"
    templatesDir = "${project.buildDir}/resources/main/$templates"
}

sourceSets {
    test {
        scala {
            srcDirs 'smoke-tests', 'acceptance-tests'
        }
    }
}

//sourceSets.main.java.srcDirs = []
sourceSets.main.scala.srcDirs += ["src/main/java", "src/main/groovy"]
//http://forums.gradle.org/gradle/topics/how_to_compile_groovy_sources_mixed_with_java_sources
sourceSets.main.groovy.srcDirs += ["src/main/java"]

test {
    exclude '**/smoke/*.class', '**/sample/*.class', '**/run/*.class'
}

task ('smoke-tests') << {
    println "Running smoke tests..."
    javaexec {
        main = 'specs2.run'
        classpath = project.sourceSets.test.runtimeClasspath
        args = ['com.ee.midas.smoke.CrudSpecs']
    }
}

task ('acceptance-tests', dependsOn: ['cleanAcceptanceReportsDir', 'journey-tests', 'driver-tests']) << {
    println "Running acceptance tests (journeys and driver-tests)"
}

task ('cleanAcceptanceReportsDir') {
    File dir = new File(project.ext.acceptanceTestReportsDir)
    !dir.exists() ?: dir.deleteDir()
}

task ('driver-tests', dependsOn: ['cleanDriverTestsReportsDir']) << {
    println "Running driver-tests..."
    project.ext.language == 'python'? runPythonAcceptanceTests(project.ext.pythonAcceptanceTestDir, project.ext.pythonAcceptanceTestReportsDir) :
        runJVMAcceptanceTests(project.ext.javaAcceptanceTestDir, project.ext.javaAcceptanceTestReportsDir)
}

task ('cleanDriverTestsReportsDir') {
    File javaReportsDir = new File(project.ext.javaAcceptanceTestReportsDir)
    !javaReportsDir.exists() ?: javaReportsDir.deleteDir()
    File pythonReportsDir = new File(project.ext.pythonAcceptanceTestReportsDir)
    !pythonReportsDir.exists() ?: pythonReportsDir.deleteDir()
}

task ('journey-tests', dependsOn: ['cleanJourneyTestReportsDir']) << {
    println "Running journey tests..."
    project.ext.language == runJVMAcceptanceTests(project.ext.acceptanceJourneyTestDir, project.ext.acceptanceJourneyTestReportsDir)

    copy {
        from (project.ext.acceptanceJourneyTestReportsDir)
        into "${project.ext.journeysDir}"
    }
}

task ('cleanJourneyTestReportsDir') {
    File dir = new File(project.ext.acceptanceJourneyTestReportsDir)
    !dir.exists() ?: dir.deleteDir()
}

task ('startMidas', dependsOn: ['killMidas', 'unzip']) << {
    def os = System.getProperty("os.name")
    def winCmd = """cmd /c midas.bat --host localhost --port 27020 --source localhost --mongoPort ${project.ext.portPrefix}17"""
    def command = os ==~ /Win.*/ ? "$winCmd" : "sh midas.sh localhost 27020 localhost ${project.ext.portPrefix}17"
    command.execute(null, new File(project.ext.explodedDir))
    println "started midas... using mongo on port ${project.ext.portPrefix}."
}

task ('killMidas') << {
    killFirst("com.ee.midas.Main")
}

def runJVMAcceptanceTests(String srcFolder, String reportsFolder) {
    javaexec {
        systemProperties['specs2.srcTestDir'] = srcFolder
        systemProperties['specs2.outDir'] = reportsFolder
        systemProperties['specs2.junit.outDir'] = reportsFolder
        main = 'org.specs2.files'
        classpath = project.sourceSets.test.runtimeClasspath
        args = ['html', 'junitxml', 'filesrunner.pattern', '(.*Specs)|(Index.*)'] //'filesrunner.verbose'
    }
}

def runPythonAcceptanceTests(String srcFolder, String reportsFolder) {
    println "cleaning reports directory..."
    def os = System.getProperty("os.name")
    println "running python tests"
    def winCmd = """cmd /c python MidasWithPythonDriverTest.py  ${reportsFolder}"""
    def command = os ==~ /Win.*/ ? "$winCmd" : "python MidasWithPythonDriverTest.py ${reportsFolder}"
    def process = command.execute(null, new File(srcFolder))
    println "available bytes: " + process.in.available()

    process.err.eachLine { line ->
        if(line.contains('FAILED') || line.contains("Error") || line.contains("Exception")) {
            throw new BuildException("python acceptance tests failed.")
        }
    }
}

// Apply External Plugins
buildscript {
    repositories {
        mavenCentral()
        mavenLocal()
    }

    dependencies {
        classpath 'net.saliman:gradle-cobertura-plugin:2.2.2'
    }
}

apply plugin: 'cobertura'

repositories {
    mavenCentral()
    mavenLocal()
    maven {
        url 'http://code.google.com/p/google-maven-repository'
        url 'https://oss.sonatype.org/content/repositories/snapshots'
        url 'http://mvnrepository.com/artifact/com.github.scopt'
    }
}

dependencies {
    compile(project.ext.mongoDriver, project.ext.groovy, project.ext.scala, project.ext.asm, project.ext.scalaStyle, project.ext.slf4j, project.ext.log4jBinding, project.ext.cglib, project.ext.scopt, project.ext.disruptor)
    testCompile(project.ext.junit, project.ext.specs2, project.ext.mockito, project.ext.spock, project.ext.pegdown)
}

jar {
    manifest {
        attributes.putAll(project.ext.manifest)
        attributes(['Sealed' : 'false'], "${project.ext.transformsPackage}")
    }

    excludes = [project.ext.deltas, project.ext.transformations, project.ext.templates]

    doLast {
        copy {
            from (configurations.compile.asPath.split(File.pathSeparator))
            into "$libsDir"
        }
    }
}

task ('createTestJar', type: Jar) {
    baseName = "${project.archivesBaseName}-test"
    destinationDir = project.distsDir
    includes = ['**/smoke/*.class', '**/fixtures/*.class', '**/run/*.class']
    includeEmptyDirs = false
    from sourceSets.test.output
}

//FindBugs Configuration
findbugs {
    toolVersion = '2.0.2'
    reportsDir = file("$reporting.baseDir/findbugs")
    effort = "max"
    reportLevel = "high"
}

tasks.withType(FindBugs) {
    excludeFilter = file("${projectDir}/tools-config/findbugs/excludeFilter.xml")
}

findbugsTest.enabled = false

//CheckStyle Configuration
checkstyle {
   configFile = file("${projectDir}/tools-config/checkstyle/checkstyle.xml")
}

checkstyleTest {
    exclude('**/*/*Specs.java')
}

//Scala Style task
task scalastyle(description: 'Run scalaStyle analysis for main and test classes') << {
//    ant.mkdir(dir: project.ext.scalaStyleReportsDirName)
//    javaexec {
//        main = 'org.scalastyle.Main'
//        classpath = sourceSets.main.runtimeClasspath
//        ext.configDir = file("${projectDir}/tools-config/scalastyle/scalaStyle.xml")
//        ext.sourceDir = 'src'
//        ext.xmlOut = file("$project.ext.scalaStyleReportsDirName/main.xml")
//        args '--config',configDir, '--xmlOutput', xmlOut, '--verbose', false, '--warnings', false, sourceDir
//    }
}

//Cobertura Configuration
cobertura {
    coverageReportDir = file(project.ext.coberturaCoverageReportsDirName)
    cobertura.coverageExcludes = ['.*net.saliman.*', '.*com.ee.midas.transform.Transformations.*',
                                  '.*MidasConfig.*', '.*com.ee.midas.dsl.Translate.*']
    coverageFormats = ['html', 'xml']
    coverageCheckTotalLineRate = project.ext.coberturaLineCoverageBaseline
    coverageCheckTotalBranchRate = project.ext.coberturaBranchCoverageBaseline
    coverageCheckHaltOnFailure = true
}

task distribute(type:Zip, dependsOn: ['assemble', 'journey-tests']) {
    doFirst {
        ant.mkdir(dir:"$distsBinDirName")
        prepareExecutables()
    }
    from project.ext.distsBinDirName
    from (project.ext.distsTemplateDir) {
        include ('**/*.txt')
    }
    from (project.ext.documentationDir) { include ('**/*.pdf') into ('docs') }
    from (project.ext.acceptanceJourneyTestReportsDir) { into ('docs/journeys') }
    from (project.ext.resourcesDir) {
        exclude('*.properties')
    }

    from ("$libsDir") { into ('libs') }
    from ("${project.ext.deltasDir}") { into ("${project.ext.deltas}") }
    from ("${project.ext.transformationsDir}") {
        exclude ('**/*.scala', '**/*.class')
        into ("${project.ext.transformations}")
    }
    from ("${project.ext.templatesDir}") { into ("${project.ext.templates}") }
    includeEmptyDirs = false
}

def prepareExecutables() {
    def allLibFiles = new File("$libsDir").list().collect { "libs/$it" }
    new File("$distsTemplateDir").list().each { filename ->
        if (filename.startsWith('midas')) {
            def contents = new File("$distsTemplateDir/$filename").text
            new FileWriter("$distsBinDirName/$filename").withWriter { writer ->
                if(filename.endsWith('.sh')) {
                    writer.append contents.replace('%%JAVA_CLASS_PATH%%', allLibFiles.collect({"\$MIDAS_HOME/$it"}).join(":"))
                }
                if(filename.endsWith('.bat')) {
                    writer.append contents.replace('%%JAVA_CLASS_PATH%%', allLibFiles.collect({"%MIDAS_HOME%/$it"}).join(";"))
                }
            }
        }
    }
}

task unzip(type: Copy) {
    def zipFile = file("$distsZipFileName")
    def outputDir = file(project.ext.explodedDir)
    from zipTree(zipFile)
    into outputDir
}

task run(description: "Runs $project.archivesBaseName", dependsOn: [distribute, unzip]) << {
    //Run Midas from exploded dir
    def runtimeClasspath = fileTree(dir: "${project.ext.explodedDir}/libs", include: '*.jar')
    runtimeClasspath = runtimeClasspath + fileTree(dir: project.distsDir, include: '*.jar')

    javaexec {
        systemProperties['portPrefix'] = project.ext.portPrefix
        main = 'com.ee.midas.Main'
        classpath = runtimeClasspath
        args = ["$project.ext.midasServer", "${project.ext.portPrefix}20", "${project.ext.mongoDB}", "${project.ext.portPrefix}17"]
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.8'
}

def getProcessId(def processName, def os) {
    def winProcessCmd = "wmic process where \"name='java.exe' and commandLine like '%$processName%'\" get processid"
    def processCmd = os ==~ /Win.*/ ? "$winProcessCmd " : 'ps -ef'
    println "Executing $processCmd on $os..."
    def killableProcessId = os ==~ /Win.*/ ?
        processCmd.execute().in.readLines().each { it.trim() }.join(" ")
    : processCmd.execute().in.filterLine {it.contains("$processName".replaceAll('\"',''))
        }
    def args = "$killableProcessId".split() as List
    def processIdToKill = ''
    if(args) {
        processIdToKill = args[1]
    }
    processIdToKill
}

def killFirst(def processName) {
    def os = System.getProperty("os.name")
    def processIdToKill = getProcessId(processName, os)
    if(!processIdToKill.isEmpty()) {
        println "Killing the process $processName with processId: $processIdToKill"
        def killProcessCmd = os ==~ /Win.*/ ? "taskkill /pid $processIdToKill /f" : "kill -15 $processIdToKill"
        println "Executing $killProcessCmd on $os..."
        killProcessCmd.execute().in.eachLine { println it }
    } else {
        println "Nothing to kill by name $processName"
    }
}

check.dependsOn << ['scalastyle']
build.dependsOn = ['check', 'cobertura', 'coberturaCheck', 'distribute']