build.gradle

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

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

  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: 'net.saliman', name: 'gradle-cobertura-plugin', version: '2.2.8'
    classpath group: 'org.kt3k.gradle.plugin', name: 'coveralls-gradle-plugin', version: '0.4.1'
    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'
  }
}

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: 'cobertura'
  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()
  }

  ext {
    runningWithCoverage = {
      allprojects.collect { it.tasks.findByName('instrument').enabled }.find()
    }

    rewriteInstrumentedLibs = {
      Boolean instrumentable = it.name.startsWith("cloudfoundry-identity-common-") || it.name.startsWith("cloudfoundry-identity-scim-") || it.name.startsWith("cloudfoundry-identity-login-")
      if (instrumentable) {
        file(it.absolutePath.replaceFirst("libs", "instrumented_libs"))
      } else {
        it
      }
    }
  }
}

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


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

  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'
            }
          }
        }
      }
    }
  }

//  apply plugin: 'artifactory'
//
//  artifactoryPublish {
//    publish {
//      contextUrl = "http://repo.spring.io"
//      repository {
//        repoKey = version.endsWith('-SNAPSHOT') ? 'libs-snapshot-local' : 'libs-release-local'
//        username = project.hasProperty('artifactory_user') ? "${artifactory_user}" : ""
//        password = project.hasProperty('artifactory_password') ? "${artifactory_password}" : ""
//        maven = true
//      }
//    }
//  }

  sourceSets {
    instrumented
  }

  task copyInstrumentedClasses(type: Copy, dependsOn: instrument) {
    from "${buildDir}/instrumented_classes"
    into sourceSets.instrumented.output.classesDir
    onlyIf { runningWithCoverage() }
  }

  task makeInstrumentedSourceSet(type: Copy, dependsOn: copyInstrumentedClasses) {
    from sourceSets.main.output.resourcesDir
    into sourceSets.instrumented.output.resourcesDir
    onlyIf { runningWithCoverage() }
  }

  task instrumentedJar(type: Jar, dependsOn: makeInstrumentedSourceSet) {
    from sourceSets.instrumented.output
    destinationDir = file("$buildDir/instrumented_libs")
    onlyIf { runningWithCoverage() }
  }
}

configurations {
  coberturaJar
}

dependencies {
  coberturaJar("net.sourceforge.cobertura:cobertura:2.0.3") {
    exclude(group: "org.mortbay.jetty")
  }
}

apply plugin: '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 }
}

task resetCoverage(type: Delete) {
  delete integrationCoverageFile
  onlyIf { runningWithCoverage() }
}

apply plugin: 'cargo'

cargoStartLocal.dependsOn assemble, prepareDatabase
cargoRunLocal.dependsOn assemble

task flushCoverageData(type: Exec) {
  commandLine "curl", "-s", "-v", "-X", "POST", "http://localhost:8080/uaa/healthz/coverage/flush"
  finalizedBy cargoStopLocal
  onlyIf { runningWithCoverage() }
}

task run(dependsOn: cargoRunLocal)

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 {
    systemProperties {
      property 'net.sourceforge.cobertura.datafile', integrationCoverageFile
      property 'spring.profiles.active', System.getProperty('spring.profiles.active', 'default')
    }

    installer {
      installUrl = 'http://archive.apache.org/dist/tomcat/tomcat-7/v7.0.55/bin/apache-tomcat-7.0.55.tar.gz'
      downloadDir = file("$buildDir/download")
      extractDir = file("$buildDir/extract")
    }
  }
}

project.gradle.taskGraph.whenReady { TaskExecutionGraph graph ->
  cargo {
    deployable {
      if (runningWithCoverage()) {
        file = file('uaa/build/instrumented_libs/cloudfoundry-identity-uaa-' + version + '.war')
      } else {
        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"

      if (runningWithCoverage()) {
        extraClasspath = files(configurations.coberturaJar.files)
      }

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

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

apply plugin: 'coveralls'

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') }

cobertura {
  coverageFormats = ['xml', 'html']
  coverageSourceDirs = [
    identityCommon.sourceSets.main.java.srcDirs,
    identityScim.sourceSets.main.java.srcDirs,
    identityLogin.sourceSets.main.java.srcDirs,
    identityUaa.sourceSets.main.java.srcDirs
  ]
  coverageMergeDatafiles = [
    new File("common/build/cobertura/cobertura.ser"),
    new File("scim/build/cobertura/cobertura.ser"),
    new File("login/build/cobertura/cobertura.ser"),
    new File("uaa/build/cobertura/cobertura.ser"),
    integrationCoverageFile
  ]
  coverageExcludes = ['.*org.cloudfoundry.identity.uaa.coverage.CoverageController']
}

assemble.dependsOn subprojects.assemble
test.dependsOn subprojects.test

// 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()