build.gradle

buildscript {
  apply from: file('shared_versions.gradle')

  repositories {
    mavenCentral()
    jcenter()
    maven {
      url 'http://repo.spring.io/plugins-release'
    }
    maven {
      url 'https://plugins.gradle.org/m2/'
    }
  }

  dependencies {
    classpath group: 'org.gradle.api.plugins', name: 'gradle-cargo-plugin', version: '1.5'
    classpath group: 'org.jfrog.buildinfo', name: 'build-info-extractor-gradle', version: '2.2.4'
    classpath group: 'org.kt3k.gradle.plugin', name: 'coveralls-gradle-plugin', version: '2.4.0'
    classpath group: 'org.mariadb.jdbc', name: 'mariadb-java-client', version:'1.1.8'
    classpath group: 'postgresql', name: 'postgresql', version:'9.1-901.jdbc3'
    classpath group: 'org.flywaydb', name: 'flyway-gradle-plugin', version: flywayVersion
    classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7'
    classpath "gradle.plugin.com.dorongold.plugins:task-tree:1.2.1"
    classpath 'org.asciidoctor:asciidoctor-gradle-plugin:1.5.3'
  }
}

apply plugin: "com.dorongold.task-tree"

ext {
  databaseType = {
    List activeProfiles = System.getProperty('spring.profiles.active', 'default').split(',')
    if (activeProfiles.contains('mysql')) {
      'mysql'
    } else if (activeProfiles.contains('postgresql')) {
      'postgresql'
    } else {
      'hsqldb'
    }
  }
  integrationCoverageFile = file("$buildDir/integration.ser")
}

apply from: file('shared_versions.gradle')

def uaaVersion = version

allprojects {
  apply plugin: 'maven'
  group = 'org.cloudfoundry.identity'
  version = uaaVersion

  apply plugin: 'jacoco'
  apply plugin: 'propdeps'
  apply plugin: 'propdeps-maven'
  apply plugin: 'propdeps-idea'
  apply plugin: 'propdeps-eclipse'
  configurations.provided.transitive = false
  apply plugin: 'eclipse-wtp'

  repositories {
    mavenCentral()
  }
}

apply plugin: 'org.flywaydb.flyway'

flyway {
  switch (databaseType()) {
    case 'mysql':
      driver = 'org.mariadb.jdbc.Driver'
      url = 'jdbc:mysql://localhost:3306/uaa'
      user = 'root'
      password = 'changeme'
      schemas = ['uaa']
      break
    case 'postgresql':
      driver = 'org.postgresql.Driver'
      url = 'jdbc:postgresql:uaa'
      user = 'root'
      password = 'changeme'
      break
  }
}

flywayClean.enabled = Boolean.valueOf(System.getProperty("flyway.clean", "true"))

task prepareDatabase {
  dependsOn { databaseType().equals('hsqldb') ? null : flywayClean }
}

apply plugin: 'cargo'

task cleanCargoConfDir {
  delete file(System.getenv('TMPDIR') + '/cargo/conf')
}

cargoStartLocal.dependsOn assemble, prepareDatabase
cargoRunLocal.dependsOn cleanCargoConfDir, assemble

task run(dependsOn: cargoRunLocal)

subprojects {
  apply plugin: 'java'
  [compileJava, compileTestJava]*.options*.compilerArgs = ['-Xlint:none', '-nowarn']
  sourceCompatibility = 1.8
  targetCompatibility = 1.8
  test {
    jvmArgs += [ "-Xmx1024m" ]
  }

  task integrationTest(type: Test) {
    dependsOn rootProject.cargoStartLocal
  }

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

  task generateDocs() {
  }

  javadoc {
    logging.captureStandardError LogLevel.INFO
    logging.captureStandardOutput LogLevel.INFO // suppress "## warnings" message
  }

  task javadocJar(type: Jar, dependsOn: javadoc) {
    classifier 'javadoc'
    from javadoc.destinationDir
  }

  artifacts {
    archives packageSources
    archives javadocJar
  }
  repositories {
    maven { url "http://maven.springframework.org/release" }
    maven { url "http://maven.springframework.org/milestone" }
    maven { url "http://maven.springframework.org/snapshot" }
    maven { url "http://objectstyle.org/maven2/" }
    maven { url "http://repo.springsource.org/ext-release-local" }
    maven { url "http://repo.maven.apache.org/maven2" }
  }

  install {
    repositories.mavenInstaller {
      pom.project {
        name 'UAA'
        description 'Cloud Foundry User Account and Authentication'
        url 'http://github.com//cloudfoundry/uaa'
        inceptionYear '2011'
        licenses {
          license {
            name 'The Apache License, Version 2.0'
            url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
            distribution 'repo'
          }
        }
        scm {
          connection 'scm:git:git@github.com:cloudfoundry/uaa.git'
          developerConnection 'scm:git:git@github.com:cloudfoundry/uaa.git'
          url 'https://github.com/cloudfoundry/uaa'
        }
        developers {
          developer {
            id 'fhanik'
            name 'Filip Hanik'
            roles {
              role 'Developer'
            }
          }
          developer {
            id 'mbhave'
            name 'Madhura Bhave'
            roles {
              role 'Developer'
            }
          }
          developer {
            id 'cdutra'
            name 'Chris Dutra'
            roles{
              role 'Developer'
            }
          }
        }
      }
    }
  }

  sourceSets {
  }

  jacocoTestReport {
    additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
    sourceDirectories = files(sourceSets.main.allSource.srcDirs)
    classDirectories =  files(sourceSets.main.output)
    reports {
      html.enabled = true
      xml.enabled = true
      csv.enabled = false
    }
  }
}

def jacocoJarPath = project.zipTree(configurations.jacocoAgent.singleFile).filter({ it.name == 'jacocoagent.jar' }).asPath
def integrationTestCoverageExecutionData = "${buildDir}/integrationTestCoverageReport.exec"

cargo {
  containerId = 'tomcat7x'
  port = 8080

  deployable {
    file = file('samples/api/build/libs/cloudfoundry-identity-api-' + version + '.war')
    context = 'api'
  }

  deployable {
    file = file('samples/app/build/libs/cloudfoundry-identity-app-' + version + '.war')
    context = 'app'
  }

  local {
    jvmArgs = "-javaagent:${jacocoJarPath}=output=file,dumponexit=true,append=false,destfile=${integrationTestCoverageExecutionData}"
    outputFile = file('uaa/build/reports/tests/uaa-server.log')
    systemProperties {
      property 'spring.profiles.active', System.getProperty('spring.profiles.active', 'default')
    }

    installer {
      installUrl = 'http://repo2.maven.org/maven2/org/apache/tomcat/tomcat/7.0.55/tomcat-7.0.55.tar.gz'
      downloadDir = file("$buildDir/download")
      extractDir = file("$buildDir/extract")
    }
  }
}

project.gradle.taskGraph.whenReady { TaskExecutionGraph graph ->
  cargo {
    deployable {
      file = file('uaa/build/libs/cloudfoundry-identity-uaa-' + version + '.war')
      context = 'uaa'
    }

    local {
//      jvmArgs = "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005"

      systemProperties {
          //property 'uaa.allowUnverifiedUsers', 'false'
          property 'smtp.host', 'localhost'
          property 'smtp.port', 2525
      }
    }
  }

  project.allprojects.collect({ it.tasks.withType(Test) }).flatten().each {
    it.systemProperty 'spring.profiles.active', System.getProperty('spring.profiles.active', 'default')
  }
}

apply plugin: 'com.github.kt3k.coveralls'

Project identityModel = subprojects.find { it.name.equals('cloudfoundry-identity-model') }
Project identityCommon = subprojects.find { it.name.equals('cloudfoundry-identity-common') }
Project identityScim = subprojects.find { it.name.equals('cloudfoundry-identity-scim') }
Project identityLogin = subprojects.find { it.name.equals('cloudfoundry-identity-login') }
Project identityUaa = subprojects.find { it.name.equals('cloudfoundry-identity-uaa') }

def publishedProjects = subprojects

assemble.dependsOn subprojects.assemble

task integrationTest {
  finalizedBy cargoStopLocal
}
integrationTest.dependsOn subprojects.integrationTest

test.dependsOn subprojects.test
test.mustRunAfter integrationTest


task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
  dependsOn = [integrationTest, test]
  additionalSourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs)
  sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
  classDirectories = files(subprojects.sourceSets.main.output)
  executionData = files(integrationTestCoverageExecutionData, subprojects.jacocoTestReport.executionData)
  reports {
    html.enabled = true
    xml.enabled = true
    csv.enabled = false
  }
  onlyIf = {
    true
  }
  doFirst {
    executionData = files(executionData.findAll {
      it.exists()
    })
  }
}

coveralls {
  sourceDirs = publishedProjects.sourceSets.main.allSource.srcDirs.flatten()
  jacocoReportPath = "${buildDir}/reports/jacoco/jacocoRootReport/jacocoRootReport.xml"
}

tasks.coveralls {
  group = 'Coverage reports'
  description = 'Uploads the aggregated coverage report to Coveralls'
}


// Log timings per task.
class TimingsListener implements TaskExecutionListener, BuildListener, org.gradle.api.tasks.testing.TestListener {
  private Clock clock
  private Clock testClock;
  private int beforeCount;
  private timings = []
  private testTimings = []
  private final testLimit = 5000
  private Task currentTask

  @Override
  void beforeExecute(Task task) {
    clock = new org.gradle.util.Clock()
    currentTask = task
  }

  @Override
  void afterExecute(Task task, TaskState taskState) {
    def ms = clock.timeInMs
    timings.add([ms, task.path])
    task.project.logger.warn "${task.path} took ${ms}ms"
  }

  @Override
  void buildFinished(BuildResult result) {
    println "Task timings:"
    for (timing in timings) {
      if (timing[0] >= 500) {
        printf "%7sms  %s\n", timing
      }
    }
    println "Test timings:"
    for (timing in testTimings.sort { it[0] }) {
      if (timing[0] >= testLimit) {
        printf "%7sms  %s\n", timing
      }
    }
  }

  @Override
  public void beforeSuite(TestDescriptor suite) {
    testClock = new org.gradle.util.Clock()
//    beforeCount = checkConnections("Before",suite);
  }

  @Override
  public void afterSuite(TestDescriptor suite, TestResult result) {
    def ms = testClock.timeInMs
    testTimings.add([ms, suite.getName()])
    currentTask.project.logger.warn "${suite.name} took ${ms}ms"
//    int afterCount = checkConnections("After",suite);
//    if (afterCount > beforeCount && beforeCount >= 0 ) {
//      System.err.println("Connection leak["+suite.getName()+"]:"+afterCount);
//    }
  }

  public int checkConnections(String action, TestDescriptor suite) {
    java.sql.Connection con = null;
    int count = -1;
    try {
      java.sql.Driver driver = Class.forName("org.postgresql.Driver").newInstance();
      java.util.Properties p = new java.util.Properties();
      p.setProperty("user","root");
      p.setProperty("password","changeme");
      con = driver.connect("jdbc:postgresql:uaa", p);
      java.sql.Statement st = con.createStatement();
      java.sql.ResultSet rs = st.executeQuery("select count(*) from pg_stat_activity");
      rs.next();
      count = rs.getInt(1);
      System.err.println(action+" Connection count["+suite.getName()+"] is: "+count);
    } finally {
      if (con!=null) {
        try { con.close();} catch (Exception ignore) {}
      }
    }
    return count;
  }

  @Override
  public void beforeTest(TestDescriptor test) {}

  @Override
  public void afterTest(TestDescriptor test, TestResult result) {}

  @Override
  void buildStarted(Gradle gradle) {}

  @Override
  void projectsEvaluated(Gradle gradle) {}

  @Override
  void projectsLoaded(Gradle gradle) {}

  @Override
  void settingsEvaluated(Settings settings) {}


}

gradle.addListener new TimingsListener()