build.gradle

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

plugins {
    id 'java'
    id 'idea'
    id "com.github.johnrengelman.shadow" version "7.1.2"
    id 'nebula.release' version '16.0.0'
}

project.ext {
    JUNIT_VERSION = '5.9.0'
    JUNIT_MOCKSERVER_VERSION = '5.0.0-alpha.10'
}

/* PROJECT DEPENDENCY VERSIONS */
// define all common versioned dependencies here
project.ext.dependencyStrings = [
    GOOGLE_GUICE: 'com.google.inject:guice:5.1.0',
    TYPESAFE_CONFIG: 'com.typesafe:config:1.4.2',
    ORG_YAML: 'org.yaml:snakeyaml:1.32',
    OKHTTP: 'com.squareup.okhttp3:okhttp:4.10.0',
    ELASTIC_APM: 'co.elastic.apm:apm-agent-api:1.34.0',
    JANSI: 'org.fusesource.jansi:jansi:2.4.0',
    PICOCLI: 'info.picocli:picocli:4.6.2'
]

/**
 * Spark provided dependencies
 * Can be used with compileOnly (from https://github.com/apache/spark/blob/master/pom.xml)
 */
project.ext.sparkDependencyStrings = [
    JACKSON_CORE: 'com.fasterxml.jackson.core:jackson-core:2.14.0',
    APACHE_COMMONS_TEXT: 'org.apache.commons:commons-text:1.10.0'
]

allprojects {
    afterEvaluate { project ->
        println "I'm configuring $project.name with version $project.version"
    }
    group = 'io.datatok'
}

subprojects {
    apply plugin: 'com.github.johnrengelman.shadow'
    apply plugin: 'nebula.release'

    if (project.name == "djobi-cli") {
        apply plugin: 'java'
    } else {
        apply plugin: 'java-library'
    }

    configurations.runtimeOnly.setCanBeResolved(true)
    configurations.compileOnly.setCanBeResolved(true)

    // https://remonsinnema.com/2016/05/09/how-to-manage-dependencies-in-a-gradle-multi-project-build/
    configurations {

    }

    tasks {
        compileJava {
            options.encoding = 'UTF-8'
            options.compilerArgs << '-Xlint:unchecked' << '-Xlint:deprecation'

            sourceCompatibility = JavaVersion.VERSION_17
            targetCompatibility = JavaVersion.VERSION_17
        }
        compileTestJava {
            options.encoding = 'UTF-8'
            options.compilerArgs << '-Xlint:unchecked' << '-Xlint:deprecation'

        }

    }

    ext.djobi = [
        /**
         * Create a task: "makeRelease"
         * - called by djobiAssemble
         */
        createRelease: {
            String projectShortName = project.name.replace("djobi-", "")
            String taskName = "makeRelease"

            shadowJar.enabled = false

            task(taskName, type: ShadowJar) {
                doFirst {
                    println "Packaging ${project.name} "
                }

                from sourceSets.main.output
                configurations = [project.configurations.djobiRelease]

                archiveFileName = "${project.name}-${project.version}-all.jar"

                relocate 'com.typesafe.config', 'my.typesafe.config'
                relocate 'com.google.inject', 'my.google.inject'
                relocate 'com.google.common', 'my.google.common'
                relocate 'okhttp3', 'my.okhttp3'
                relocate 'okio', 'my.okio'
/*
                minimize {
                    exclude(
                        'org.elasticsearch:.*:.*',
                        'com.databricks:.*:.*'
                    )
                }
                */
            }

            shadowJar.dependsOn(taskName)
        },

        /**
         * Create a task: "{variant}MakeRelease"
         * - called by djobiAssemble
         */
        createReleaseWithVariants: { variants ->
            String projectShortName = project.name.replace("djobi-", "")
            //project.gradle.startParameter.excludedTaskNames.add('ShadowJar')
            shadowJar.enabled = false

            variants.each { variant ->
                String taskName = "${variant.name}MakeRelease"

                task(taskName, type: ShadowJar) {
                    doFirst {
                        println "Packaging variant ${project.name} / ${variant.name} "
                    }

                    classifier = "${variant.name}"
                    from sourceSets.main.output
                    configurations = [project.configurations."${variant.name}"]

                    archiveFileName = "${project.name}-${variant.name}-${project.version}-all.jar"

                    relocate 'com.typesafe.config', 'my.typesafe.config'
                    relocate 'com.google.inject', 'my.google.inject'
                    relocate 'com.google.common', 'my.google.common'
                    relocate 'okhttp3', 'my.okhttp3'
                    relocate 'okio', 'my.okio'

                    minimize {
                        exclude(dependency('org.elasticsearch:.*:.*'))
                    }
                }

                shadowJar.dependsOn(taskName)
            }
        }
    ];

    task allDeps(type: DependencyReportTask) {}

    repositories {
        mavenCentral()
    }

    dependencies {
        testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: "${JUNIT_VERSION}"
        testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: "${JUNIT_VERSION}"

        testImplementation(
            [group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: "${JUNIT_VERSION}"],
            [group: 'org.junit.jupiter', name: 'junit-jupiter-params', version: "${JUNIT_VERSION}"],
            [group: 'com.squareup.okhttp3', name: 'mockwebserver3-junit5', version: "${JUNIT_MOCKSERVER_VERSION}"]
        )
    }

    sourceSets {
        test {
            compileClasspath += configurations.compileOnly
        }
    }

    test {
        if (System.getProperty("includeIntegrationTests") == null) {
            useJUnitPlatform {
                excludeTags("IntegrationTest", "NeedDocker")
            }
        }

        environment "projectRoot", System.getProperty("user.dir")
        environment "SPARK_LOCAL_IP", "127.0.0.1"

        jvmArgs (
            '-Dconfig.file=./src/test/resources/env.conf',
            '-Dlog4j.configuration=log4j.properties',
            '-Djunit.jupiter.extensions.autodetection.enabled=true',
            '--add-opens=java.base/java.lang=ALL-UNNAMED',
            '--add-opens=java.base/java.lang.invoke=ALL-UNNAMED',
            '--add-opens=java.base/java.lang.reflect=ALL-UNNAMED',
            '--add-opens=java.base/java.io=ALL-UNNAMED',
            '--add-opens=java.base/java.net=ALL-UNNAMED',
            '--add-opens=java.base/java.nio=ALL-UNNAMED',
            '--add-opens=java.base/java.util=ALL-UNNAMED',
            '--add-opens=java.base/java.util.concurrent=ALL-UNNAMED',
            '--add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED',
            '--add-opens=java.base/sun.nio.ch=ALL-UNNAMED',
            '--add-opens=java.base/sun.nio.cs=ALL-UNNAMED',
            '--add-opens=java.base/sun.security.action=ALL-UNNAMED',
            '--add-opens=java.base/sun.util.calendar=ALL-UNNAMED',
            '--add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED'
        )

        testLogging {
            exceptionFormat = "short"

            debug {
                events "started", "skipped", "failed"
                exceptionFormat "short"
            }
        }

        failFast = false
        testLogging.showStandardStreams = true
        maxParallelForks = 1
        //reports.html.enabled = false
    };
};

nebulaRelease {
    releaseBranchPatterns = [/master/, /HEAD/, /(release(-|\/))?v?\d+\.\d+\.\d+/]
};

task djobiAssemble(type: Sync) {
    doFirst {
        file("$buildDir/release").delete()
    }

    doLast {
        copy {
            from 'djobi-core/build/manifest/djobi-core.properties'
            into "$buildDir/release"
        }

        copy {
            from 'djobi-cli/src/main/release'
            filter { line -> line.replaceAll('%%VERSION%%', project.version.toString()) }
            into "$buildDir/release"
            fileMode = 0744
        }
    }

    from(subprojects.findAll { (it.name != "djobi-tests") }.collect { it.tasks.withType(ShadowJar) }) {
        include "**/*-all.jar"
        into "libs"
        rename '^(.+)-all.jar', '$1.jar'
    }

    into "$buildDir/release"
};

task testReport(type: TestReport) {
    destinationDir = file("$buildDir/reports/allTests")
    // Include the results from the `test` task in all subprojects
    reportOn subprojects*.test

    //
    // Keep track of total failure count for later test and output
    //
    def testFailures = 0

    //
    // Every subproject should ignore test failures, but here we add a
    // test suite failure filter to ensure we keep track of the fact that
    // failures have occurred (for the build failure check below)
    //
    subprojects {
        test {
            ignoreFailures true
            afterSuite { td, tr ->
                if (td.getParent() == null) {
                    testFailures += tr.getFailedTestCount()
                }
            }
        }
    }

    //
    // The last thing to do in this task is to check for failures.
    // The build as a whole should fail if any tests failed.
    //
    doLast {
        if (testFailures > 0) {
            throw new Exception("There were ${testFailures} test failures")
        }
    }
};

//
// Add the test report to the dependency tree for a standard build
//
build.dependsOn(testReport);

/**
 * Relocate some common libs, to prevent conflicts.
 */
shadowJar {
    relocate 'com.typesafe.config', 'io.datatok.djobi.typesafe.config'
    relocate 'com.google.inject', 'io.datatok.djobi.google.inject'
    relocate 'com.google.common', 'io.datatok.djobi.google.common'
    relocate 'okhttp3', 'io.datatok.djobi.okhttp3'
    relocate 'okio','io.datatok.djobi.okio'

    minimize()
}

defaultTasks 'build'