build.gradle

/*
 * Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

buildscript {
    dependencies {
        classpath 'org.openjdk.skara.gradle:skara-reproduce'
        classpath 'org.openjdk.skara.gradle:skara-proxy'
        classpath 'org.openjdk.skara.gradle:skara-version'
        classpath 'org.openjdk.skara.gradle:skara-images'
        classpath 'org.openjdk.skara.gradle:skara-module'
    }
}

plugins {
    id 'skara-proxy'
    id 'skara-version'
    id 'skara-reproduce'
}

configure(subprojects.findAll() { it.name != 'bots' }) {
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'skara-module'
    apply plugin: 'skara-version'

    group = 'org.openjdk.skara'

    repositories {
        mavenLocal()
        maven {
            url System.getProperty('maven.url', 'https://repo.maven.apache.org/maven2/')
        }
    }

    dependencies {
        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
        testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.2'
        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
        // Force Gradle to load the JUnit Platform Launcher from the module-path, as
        // configured in buildSrc/.../ModulePlugin.java -- see SKARA-69 for details.
        testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.8.2'
    }

    tasks.withType(JavaCompile).configureEach {
        options.release.set(17)
    }

    compileJava.options.encoding = 'UTF-8'
    compileTestJava.options.encoding = 'UTF-8'

    test {
        useJUnitPlatform()

        if (findProperty('credentials')) {
            systemProperty "credentials", findProperty('credentials')
        }

        testLogging {
            events "passed", "skipped", "failed"
            exceptionFormat "full"
        }

        reports.html.required = false
    }

    tasks.withType(Test).configureEach {
        maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
    }

    tasks.withType(Test).configureEach {
        forkEvery = 100
    }

    tasks.withType(Test).configureEach {
        reports.html.required = false
        reports.junitXml.required = false
    }

    tasks.withType(JavaCompile).configureEach {
        options.fork = true
    }

    publishing {
        repositories {
            maven {
                url = findProperty('mavenRepositoryUrl')
                credentials {
                    username = findProperty('mavenRepositoryUser')
                    password = findProperty('mavenRepositoryPassword')
                }
            }
        }
    }

    gradle.taskGraph.whenReady { graph ->
        if (graph.hasTask(publish) && !findProperty('mavenRepositoryUrl')) {
            throw new GradleException("To publish artifacts, set the maven repository url -PmavenRepositoryUrl=<url>")
        }
        if (graph.hasTask(publish) && !findProperty('mavenRepositoryUser')) {
            throw new GradleException("To publish artifacts, set the maven repository user name -PmavenRepositoryUser=<user>")
        }
        if (graph.hasTask(publish) && !findProperty('mavenRepositoryPassword')) {
            throw new GradleException("To publish artifacts, set the maven repository password -PmavenRepositoryPassword=<password>")
        }
    }
}

task test {
    subprojects.findAll() { !it.getTasksByName('test', false).isEmpty() }.each { dependsOn "${it.path}:test" }
}

task testReport(type: TestReport) {
    destinationDirectory = file("$buildDir/reports/allTests")
    getTestResults().from(subprojects.findAll()*.getTasksByName('test', false))
}

task clean {
    subprojects.findAll() { !it.getTasksByName('clean', false).isEmpty() }.each { dependsOn "${it.path}:clean" }
}

reproduce {
    dockerfile = 'test.dockerfile'
}

def getOS() {
    def os = System.getProperty('os.name').toLowerCase()
    if (os.startsWith('linux')) {
        return 'linux'
    }
    if (os.startsWith('mac')) {
        return 'macos'
    }
    if (os.startsWith('win')) {
        return 'windows'
    }
    if (os.startsWith('sunos')) {
        return 'solaris'
    }
    throw new GradleException("Unexpected operating system: " + os)
}

def getCPU() {
    def cpu = System.getProperty('os.arch').toLowerCase()
    if (cpu.startsWith('amd64') || cpu.startsWith('x86_64') || cpu.startsWith('x64')) {
        return 'x64'
    }
    if (cpu.startsWith('x86') || cpu.startsWith('i386')) {
        return 'x86'
    }
    if (cpu.startsWith('sparc')) {
        return 'sparc'
    }
    if (cpu.startsWith('ppc')) {
        return 'ppc'
    }
    if (cpu.startsWith('arm')) {
        return 'arm'
    }
    if (cpu.startsWith('aarch64')) {
        return 'aarch64';
    }
    throw new GradleException("Unexpected CPU: " + cpu)
}

task local(type: Copy) {
    doFirst {
        delete project.buildDir
    }

    def os = getOS()
    def cpu = getCPU()

    if (os in ['linux', 'macos', 'windows'] && cpu == 'x64') {
        def target = os.substring(0, 1).toUpperCase() + os.substring(1) +
                     cpu.substring(0, 1).toUpperCase() + cpu.substring(1)
        dependsOn ':cli:image' + target
    } else {
        dependsOn ':cli:imageLocal'
    }

    from zipTree(file(project.rootDir.toString() +
                      '/cli/build/distributions/cli' +
                      '-' + project.version + '-' +
                      os + '-' + cpu + '.zip'))
    into project.buildDir
}

task bots(type: Copy) {
    doFirst {
        delete project.rootDir.toString() + '/bots/bin'
    }

    dependsOn ':bots:cli:images'

    def os = getOS()
    def cpu = getCPU()

    from zipTree(file(project.rootDir.toString() +
                      '/bots/cli/build/distributions/cli' +
                      '-' + project.version + '-' +
                      os + '-' + cpu + '.zip'))
    into project.rootDir.toString() + '/bots/bin'
}

task offline(type: Copy) {
    doFirst {
        delete project.buildDir
    }

    def os = getOS()
    def cpu = getCPU()

    dependsOn ':cli:imageLocal'
    from zipTree(file(project.rootDir.toString() +
                      '/cli/build/distributions/cli' +
                      '-' + project.version + '-' +
                      os + '-' + cpu + '.zip'))
    into project.buildDir
}

defaultTasks 'local'