build.gradle

/* This project uses Java and Eclipse. */
import org.gradle.plugins.ide.eclipse.model.SourceFolder
apply plugin: "java"
apply plugin: "eclipse"
/* Coveralls with JaCoCo */
apply plugin: 'jacoco'
apply plugin: 'com.github.kt3k.coveralls'

/* Set up group and version info for myria */
archivesBaseName = "myria"
group = "edu.washington.escience.myria"
version = "0.1"

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

/* We use Java 1.7 */
sourceCompatibility = 1.7
targetCompatibility = 1.7

/* Gradle's build script */
buildscript {
  repositories {
    mavenCentral()
  }

  dependencies {
    classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.0.0'
  }
}
/* Tell gradle where the source code is located. */
sourceSets {
  /* Code for main */
  main {
    java.srcDir 'src'
    java.srcDir 'protobuf/java'
    java.srcDir 'third-party-src'
    resources.srcDir 'conf'
    output.classesDir = 'build/main'
  }
  /* Code for tests */
  test {
    java.srcDir 'test'
    output.classesDir = 'build/test'
  }
  /* Code for systemtests */
  systemtest {
    java.srcDir 'systemtest'
    output.classesDir = 'build/systemtest'
  }
  /* Code for speedtests */
  speedtest {
    java.srcDir 'speedtest'
    output.classesDir = 'build/speedtest'
  }
  /* Code for testsuites */
  testsuites {
    java.srcDir 'testsuites'
    output.classesDir = 'build/testsuites'
  }
}


/* Compile, but don't run the speed tests when building the project. */
check.dependsOn speedtestClasses
check.dependsOn systemtestClasses
check.dependsOn testsuitesClasses
/* Build the Eclipse .classpath file first, because if Gradle's build fails
 * we'll want to use Eclipse to debug it. */
test.dependsOn eclipseClasspath
tasks.eclipseClasspath.dependsOn cleanEclipseClasspath

/*
 * List the compile and runtime dependencies of all the tests.
 * Note that "group:name:version" dependencies will be downloaded from Maven.
 */

/* Where we will fetch external JAR files from. */
repositories {
  mavenCentral() /* The standard Java Maven repository. */
  maven { url "http://clojars.org/repo" } /* Clojars, for MonetDB */
  flatDir {
    name 'localRepository'
  }
}

repositories.localRepository {
  dirs './lib'
}

/* List constants that we use in multiple places. */
ext.slf4jVersion = "1.7.9"
ext.jacksonVersion = "2.4.4"
ext.jerseyVersion = "2.14"
ext.swaggerVersion = "2.11"
ext.swaggerMinorVersion = "1.3.11"

dependencies {
  compile ("org.apache.hadoop:hadoop-core:1.2.1") {
    /* Hadoop depends on Jersey 1 but we don't need it. Exclude it to prevent
     * Classloader picking the wrong version of Jersey classes. */
    exclude group: "com.sun.jersey"
  }

  compile "xerces:xercesImpl:2.11.0"
  compile "xalan:xalan:2.7.2"
  compile "com.google.code.findbugs:annotations:3.0.0"
  compile "net.jcip:jcip-annotations:1.0"
  compile "org.ini4j:ini4j:0.5.2"
  compile "com.almworks.sqlite4java:sqlite4java:1.0.392"

  compile "com.google.guava:guava:18.0"
  compile "com.google.protobuf:protobuf-java:2.6.1"

  compile "io.netty:netty:3.9.6.Final"

  compile "com.goldmansachs:gs-collections:5.1.0"
  compile "com.goldmansachs:gs-collections-api:5.1.0"

  compile "joda-time:joda-time:2.6"

  compile "commons-io:commons-io:2.4"
  compile "org.apache.commons:commons-lang3:3.3.2"
  compile "commons-cli:commons-cli:1.2"

  compile "org.glassfish.jersey.core:jersey-server:${jerseyVersion}"
  compile "org.glassfish.jersey.core:jersey-client:${jerseyVersion}"
  compile "org.glassfish.jersey.core:jersey-common:${jerseyVersion}"
  compile "org.glassfish.jersey.containers:jersey-container-grizzly2-http:${jerseyVersion}"
  compile "org.glassfish.jersey.media:jersey-media-multipart:${jerseyVersion}"
  compile "org.glassfish.jersey.media:jersey-media-json-jackson:${jerseyVersion}"

  compile "javax.annotation:javax.annotation-api:1.2"

  compile "com.fasterxml.jackson.jaxrs:jackson-jaxrs-providers:${jacksonVersion}"
  compile "com.fasterxml.jackson.datatype:jackson-datatype-joda:${jacksonVersion}"
  compile "com.fasterxml.jackson.datatype:jackson-datatype-guava:${jacksonVersion}"

  compile "com.wordnik:swagger-jersey2-jaxrs_${swaggerVersion}:${swaggerMinorVersion}"

  compile "org.slf4j:slf4j-api:${slf4jVersion}"
  //runtime "org.slf4j:slf4j-simple:${slf4jVersion}"
  runtime "org.slf4j:slf4j-log4j12:${slf4jVersion}"

  compile "org.apache.commons:commons-csv:1.1"
  
  // Expression compiler
  compile "org.codehaus.janino:janino:2.7.7"

  compile "org.postgresql:postgresql:9.3-1102-jdbc41"

  testCompile "junit:junit:4.12"
  testCompile "com.carrotsearch:junit-benchmarks:0.7.2"

  systemtestCompile sourceSets.main.output
  systemtestCompile configurations.testCompile
  systemtestCompile sourceSets.test.output
  systemtestRuntime configurations.testRuntime

  speedtestCompile sourceSets.main.output
  speedtestCompile configurations.systemtestCompile
  speedtestCompile sourceSets.systemtest.output
  speedtestRuntime configurations.systemtestRuntime

  testsuitesCompile sourceSets.main.output
  testsuitesCompile configurations.systemtestCompile
  testsuitesCompile sourceSets.systemtest.output
  testsuitesRuntime configurations.systemtestRuntime
}

/* Tell Java to emit all compiler warnings. */
tasks.withType(JavaCompile) {
  options.compilerArgs << "-Xlint"
}

/* Tell all tasks to add sqlite library to their classpath when running. */
tasks.withType(Test) {
  systemProperty "java.library.path", file("lib/sqlite4java-392")
  getReports().getHtml().setDestination(file('build/reports/'+name))

  // set heap size for the test JVM(s)
  minHeapSize = "512m"
  maxHeapSize = "2048m"
}

/* Tell gradle where additional tests & testsuites should look for classes. */
task systemtest(type: Test) {
  testClassesDir = sourceSets.systemtest.output.classesDir
  classpath = sourceSets.systemtest.runtimeClasspath
}
task speedtest(type: Test) {
  testClassesDir = sourceSets.speedtest.output.classesDir
  classpath = sourceSets.speedtest.runtimeClasspath
}
task testsuites(type: Test) {
  testClassesDir = sourceSets.testsuites.output.classesDir
  classpath = sourceSets.testsuites.runtimeClasspath
}

/* The eclipseClasspath task will build a local Eclipse .classpath file. */
eclipse.classpath {
  /* Ensure Eclipse compiled output appears in build directory. */
  defaultOutputDir = file('build/main')

  /* Download library sources and Javadoc for use in debugging. */
  downloadSources = true
  downloadJavadoc = true

  file {

  /* Ugly hack to stick the JNI pointer for sqlite into the .classpath file. */
    withXml {
      provider -> 
      provider.asNode().findAll { it.@path.contains("sqlite") }.each { 
        it.children().each {
          it.appendNode('attribute', [name: 'org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY', value:'myria/lib/sqlite4java-392'])
        }
      }
    }

    /* Separate output folder for each src folders*/
    whenMerged {
      cp ->
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("src") }*.output = "build/main"
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("protobuf") }*.output = "build/main"
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("third-party-src") }*.output = "build/main"
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("test") }*.output = "build/test"
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("systemtest") }*.output = "build/systemtest"
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("speedtest") }*.output = "build/speedtest"
      cp.entries.findAll { it instanceof SourceFolder && it.path.startsWith("testsuites") }*.output = "build/testsuites"
    }

  }
}

tasks.withType(Test) {
    /* Optional: uncomment the next line to print which test is running. Useful for debugging. */
    beforeTest { desc -> println "Executing test ${desc.name} [${desc.className}]" }
    testLogging { exceptionFormat = 'full' }
}

/*
 * Copy all the jars that this project depends on into `build/libs`, and make
 * sure it this happens whenever jar is run.
 */
task copyToLib(type: Copy) {
    into "$buildDir/libs"
    from configurations.runtime
}
tasks.jar.dependsOn copyToLib

/* Make sure test runs before any other type of tests */
systemtest.dependsOn test
speedtest.dependsOn test

/* allTests just runs all tests */
task allTests
allTests.dependsOn test
allTests.dependsOn systemtest
allTests.dependsOn speedtest

/* Make check run system tests. */
check.dependsOn systemtest

/* Assemble the Myria jar into `build/libs` */
jar {
  manifest {
    attributes("Implementation-Title" : "Myria",
               "Implementation-Version": version,
	       "Main-Class": "edu.washington.escience.myria.daemon.MasterDaemon")
  }
}

/* Coveralls */
jacocoTestReport {
  executionData(test, systemtest)
  reports {
    xml.enabled = true // coveralls plugin depends on xml format report
    html.enabled = true
  }
}

/* Update the version and branch in constants.java. */
task updateCommitInfo(type:Exec) {
  commandLine './update_commit_id.sh'
}
compileJava.dependsOn updateCommitInfo
eclipseClasspath.dependsOn updateCommitInfo