build.gradle

import org.apache.commons.lang.time.StopWatch
import org.apache.tools.ant.filters.ReplaceTokens

import java.nio.file.Files
import java.nio.file.Paths

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

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

    dependencies {
        classpath group: 'com.bmuschko', name: 'gradle-cargo-plugin', version: '2.2.3'
        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: 'com.microsoft.sqlserver', name: 'mssql-jdbc', version: '6.1.0.jre8'
        classpath group: 'org.flywaydb', name: 'flyway-gradle-plugin', version: flywayVersion
        classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.7'
        classpath 'org.asciidoctor:asciidoctor-gradle-plugin:1.5.3'
        classpath group: 'com.moowork.gradle', name: 'gradle-node-plugin', version: '1.1.0'
    }
}

ext {
    databaseType = {
        List activeProfiles = System.getProperty('spring.profiles.active', 'default').split(',')
        if (activeProfiles.contains('mysql')) {
            'mysql'
        } else if (activeProfiles.contains('postgresql')) {
            'postgresql'
        } else if (activeProfiles.contains('sqlserver')) {
            'sqlserver'
        } 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: 'propdeps'
    apply plugin: 'propdeps-maven'
    apply plugin: 'propdeps-idea'
    apply plugin: 'propdeps-eclipse'
    configurations.provided.transitive = false
    apply plugin: 'eclipse-wtp'

    repositories {
        mavenCentral()
        maven {
            url 'https://build.shibboleth.net/nexus/content/repositories/releases/'
        }
        maven { url 'http://repository.mulesoft.org/releases/'}
    }
    task sourceJar(type: Jar) {
        from sourceSets.main.allJava
        classifier "sources"
    }
    apply plugin: 'maven-publish'

    publishing {
        repositories {
            maven {
                url "https://oss.sonatype.org/content/repositories/releases/"
                credentials {
                    username "$nexusUsername"
                    password "$nexusPassword"
                }
            }
        }
    }
}

apply plugin: 'com.bmuschko.cargo'
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']
            locations = ['filesystem:server/src/main/resources/org/cloudfoundry/identity/uaa/db/mysql']
            break
        case 'postgresql':
            driver = 'org.postgresql.Driver'
            url = 'jdbc:postgresql:uaa'
            user = 'root'
            password = 'changeme'
            locations = ['filesystem:server/src/main/resources/org/cloudfoundry/identity/uaa/db/postgresql']
            break
        case 'sqlserver':
            driver = 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
            url = 'jdbc:sqlserver://localhost:1433;database=uaa;'
            user = 'root'
            password = 'changemeCHANGEME1234!'
            locations = ['filesystem:server/src/main/resources/org/cloudfoundry/identity/uaa/db/sqlserver']
            break
    }
}

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

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

task cleanCargoConfDir {
    delete file(System.getProperty('java.io.tmpdir') + '/cargo/conf')
    try {
        Files.createDirectory(Paths.get(System.getProperty('java.io.tmpdir') + '/cargo'))
    } catch (all) {
    }
}

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

task run(dependsOn: cargoRunLocal)

task manifests(dependsOn: assemble, type: Copy) {
    from('uaa/src/test/resources/sample-manifests') {
        include '**/*.yml'
        filter(ReplaceTokens,
                tokens: [
                        version: uaaVersion,
                        app: System.getProperty('app', 'myuaa'),
                        appdomain: System.getProperty('app-domain', 'bosh-lite.com'),
                ]
        )
    }
    into 'build/sample-manifests'
}


subprojects {
    apply plugin: 'java'

    dependencies {
        testCompile('com.github.sbrannen:spring-test-junit5:1.2.0')
        testCompile("org.junit.jupiter:junit-jupiter-api:5.2.0")
        testRuntime("org.junit.jupiter:junit-jupiter-engine:5.2.0")
        testRuntime("org.junit.vintage:junit-vintage-engine:5.2.0")
    }

    [compileJava, compileTestJava]*.options*.compilerArgs = ['-Xlint:none', '-nowarn']
    sourceCompatibility = 1.8
    targetCompatibility = 1.8
    test {
        useJUnitPlatform()
        jvmArgs += ["-Xmx1024m", "-XX:+StartAttachListener"]
    }

    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 'https://jitpack.io' }
        maven { url "https://repo.spring.io/release" }
        maven { url "https://repo.spring.io/milestone" }
        maven { url "https://repo.spring.io/snapshot" }
        maven { url "https://repo.spring.io/ext-release-local" }
        maven { url "https://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 {
    }
}



publishing {
    publications {
        uaa_parent(MavenPublication) {
            groupId 'org.cloudfoundry.identity'
            version uaaVersion
            artifactId 'cloudfoundry-identity-parent'

            from components.java
            artifact sourceJar
        }
    }
}

def integrationTestCoverageExecutionData = "${buildDir}/integrationTestCoverageReport.exec"

cargo {
    containerId = tomcatContainerId
    port = 8080

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

    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 {
        timeout = 540000
        List activeProfiles = System.getProperty('spring.profiles.active', '').split(',')
        if (activeProfiles.contains('debug')) {
            jvmArgs = "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -DLOGIN_CONFIG_URL=file://" + new File(".").absolutePath + "/uaa/src/main/resources/required_configuration.yml"
        } else {
            jvmArgs = "-DLOGIN_CONFIG_URL=file://" + new File(".").absolutePath + "/uaa/src/main/resources/required_configuration.yml"
        }
        outputFile = file('uaa/build/reports/tests/uaa-server.log')
        configFile {
            file = file('scripts/travis/tomcat-conf/context.xml')
            toDir = 'conf'

        }
        systemProperties {
            property 'spring.profiles.active', System.getProperty('spring.profiles.active', 'default')
            property 'metrics.perRequestMetrics', System.getProperty('metrics.perRequestMetrics', 'true')
        }

        installer {
            installUrl = 'https://repo1.maven.org/maven2/org/apache/tomcat/tomcat/' + tomcatVersion + '/tomcat-' + tomcatVersion + '.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 {

            systemProperties {
                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 identityServer = subprojects.find { it.name.equals('cloudfoundry-identity-server') }
Project identityStatsd = subprojects.find { it.name.equals('cloudfoundry-identity-statsd') }
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 mockAssertion(type: JavaExec) {
    main = 'org.cloudfoundry.identity.uaa.saml.MockSamlAssertion'
    args = System.getProperty("file", null) == null ? [] : [System.getProperty("file")]
    classpath = files(subprojects.sourceSets.test.runtimeClasspath)
}

task encrypt(type: JavaExec) {
    main = 'org.cloudfoundry.identity.uaa.Encryptor'
    args = System.getProperty("encryptArgs", null) == null ? [] : System.getProperty("encryptArgs").split(",").toList()
    classpath = files(subprojects.find {it.name.contains('server') }.sourceSets.test.runtimeClasspath)
}

task decrypt(type: JavaExec) {
    main = 'org.cloudfoundry.identity.uaa.Decryptor'
    args = System.getProperty("decryptArgs", null) == null ? [] : System.getProperty("decryptArgs").split(",").toList()
    classpath = files(subprojects.find {it.name.contains('server') }.sourceSets.test.runtimeClasspath)
}

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

    @Override
    void beforeExecute(Task task) {
        clock = new StopWatch()
        clock.start()
        currentTask = task
    }

    @Override
    void afterExecute(Task task, TaskState taskState) {
        clock.stop()
        def ms = clock.getTime()
        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
    void beforeSuite(TestDescriptor suite) {
        testClock = new StopWatch()
        testClock.start()
    }

    @Override
    void afterSuite(TestDescriptor suite, TestResult result) {
        def ms = testClock.getTime()
        testTimings.add([ms, suite.getName()])
        currentTask.project.logger.warn "${suite.name} took ${ms}ms"
    }

    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
    void beforeTest(TestDescriptor test) {}

    @Override
    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()