build.gradle

import groovy.json.JsonOutput

plugins {
//    Observing higher memory usage with task-tree plugin. Disabling except if needed
//    id "com.dorongold.task-tree" version "2.1.1"
    id "com.diffplug.spotless" version '7.0.2'
    id 'io.freefair.lombok' version '8.6' apply false
    id 'jacoco'
    id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
    id 'me.champeau.jmh' version '0.7.2' apply false
}

allprojects {
    repositories {
        mavenCentral()
    }
}


// Ensure Capture Proxy and Dependencies are built with JDK 11 for On Node Install

// Cache dependencies during the configuration phase
ext.captureProxyDependencies = []
gradle.projectsEvaluated {
    def captureProxyProject = rootProject.project(":TrafficCapture:trafficCaptureProxyServer")
    captureProxyDependencies = captureProxyProject.configurations.collectMany { configuration ->
        configuration.dependencies.findAll { it instanceof ProjectDependency }.collect { it.dependencyProject.path }
    }
    // Add the TrafficCaptureProxyServer project itself
    captureProxyDependencies << captureProxyProject.path
}

// Modify sourceCompatibility during the execution phase
gradle.taskGraph.whenReady { taskGraph ->
    allprojects {
        tasks.withType(JavaCompile).configureEach {
            if (project.path in rootProject.captureProxyDependencies) {
                sourceCompatibility = JavaVersion.VERSION_11
                targetCompatibility = JavaVersion.VERSION_11
            } else {
                sourceCompatibility = JavaVersion.VERSION_17
                targetCompatibility = JavaVersion.VERSION_17
            }
        }
    }
}

// Define version properties
ext {
    // support -Dbuild.version, but include default
    buildVersion = System.getProperty("build.version", "0.1.0")
    // support -Dbuild.snapshot=false, but default to true
    buildSnapshot = System.getProperty("build.snapshot", "true") == "true"
    finalVersion = buildSnapshot ? "${buildVersion}-SNAPSHOT" : buildVersion
}

allprojects {
    version = finalVersion
    // This should eventually change, see https://opensearch.atlassian.net/browse/MIGRATIONS-2167
    group = 'org.opensearch.migrations.trafficcapture'
    tasks.withType(Jar).tap {
        configureEach {
            manifest {
                attributes(
                        'SPDX-License-Identifier': 'Apache-2.0'
                )
            }
        }
    }
}

subprojects { subproject ->
    subproject.afterEvaluate {
        if (subproject.plugins.hasPlugin('java') && subproject.name != 'commonDependencyVersionConstraints') {
            subproject.dependencies {
                implementation project(":commonDependencyVersionConstraints")
                annotationProcessor project(":commonDependencyVersionConstraints")
                if (subproject.plugins.hasPlugin('java-test-fixtures')) {
                    testFixturesImplementation project(":commonDependencyVersionConstraints")
                }
            }
        }
    }
}

task buildDockerImages() {
    dependsOn(':TrafficCapture:dockerSolution:buildDockerImages')
    dependsOn(':DocumentsFromSnapshotMigration:buildDockerImages')
}

def commonExclusions = ['**/build/**', '**/node_modules/**', '**/opensearch-cluster-cdk/**', '**/cdk.out/**']
spotless {
    format 'misc', {
        target fileTree('.') {
            include '**/*.gradle', '.gitattributes', '.gitignore'
            exclude commonExclusions
        }
        trimTrailingWhitespace()
        leadingTabsToSpaces()
        endWithNewline()

    }
    yaml {
        target fileTree('.') {
            include '**/*.yml'
            exclude commonExclusions
        }
        trimTrailingWhitespace()
        leadingTabsToSpaces()
        endWithNewline()
    }
    json {
        target fileTree('.') {
            include '*.json'
            exclude commonExclusions
        }
        prettier()
        endWithNewline()
    }
}

subprojects {
    apply plugin: "com.diffplug.spotless"
    apply plugin: 'jacoco'
    apply plugin: 'java'
    apply plugin: 'maven-publish'

    java {
        toolchain {
            languageVersion.set(JavaLanguageVersion.of(17))
            vendor.set(JvmVendorSpec.AMAZON)
        }
    }

    // See https://github.com/diffplug/spotless/tree/main/plugin-gradle#java for some documentation,
    // though what '#' does is still undocumented from what I can tell
    spotless {
        java {
            target "**/*.java"
            targetExclude '**/build/**', ".gradle/**"
            importOrder(
                    'javax',
                    'java',
                    'org.opensearch',
                    '',
                    '\\#')
            leadingTabsToSpaces()
            endWithNewline()
            removeUnusedImports()
        }
    }

    tasks.withType(Test) {
        // Getting javadoc to compile is part of the test suite to ensure we are able to publish our artifacts
        dependsOn project.javadoc
    }
    if (!sourceSets.test.allSource.files.isEmpty()) {
        tasks.withType(Test) {
            testLogging {
                events "passed", "skipped", "failed"
                exceptionFormat "full"
                showExceptions true
                showCauses true
                showStackTraces true
            }
            maxParallelForks = gradle.startParameter.maxWorkerCount

            // Provide way to exclude particular tests from CLI
            // e.g. ../gradlew test -PexcludeTests=**/KafkaProtobufConsumerLongTermTest*
            if (project.hasProperty('excludeTests')) {
                exclude project.property('excludeTests')
            }

            useJUnitPlatform()
            //  Disable parallel test execution, see MIGRATIONS-1666
            systemProperty 'junit.jupiter.execution.parallel.enabled', 'false'
            systemProperty 'log4j2.contextSelector', 'org.apache.logging.log4j.core.selector.BasicContextSelector'
            // Verify assertions in tests
            jvmArgs = ['-ea', '-XX:+HeapDumpOnOutOfMemoryError']
            jacoco {
                enabled = true
                destinationFile = layout.buildDirectory.file("jacoco/${project.path.replace(':', '-')}-${project.name}-${name}.exec").get().asFile
            }
        }
        // Mutually exclusive tests to avoid duplication
        tasks.named('test') {
            systemProperty 'migrationLogLevel', 'TRACE'
            useJUnitPlatform {
                excludeTags('longTest', 'isolatedTest')
            }
        }

        tasks.register('slowTest', Test) {
            systemProperty 'migrationLogLevel', 'DEBUG'
            useJUnitPlatform {
                includeTags 'longTest'
                excludeTags 'isolatedTest'
            }
        }

        tasks.register('isolatedTest', Test) {
            maxParallelForks = 1
            useJUnitPlatform {
                includeTags 'isolatedTest'
            }
        }

        tasks.register('fullTest') {
            dependsOn test
            dependsOn slowTest
            dependsOn isolatedTest
        }
    } else {
        tasks.withType(Test) {
            jacoco {
                enabled = false
            }
        }
    }

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

    task sourcesJar(type: Jar) {
        archiveClassifier.set('sources')
        from sourceSets.main.allSource
        duplicatesStrategy = DuplicatesStrategy.WARN
    }

    def excludedProjectPaths = [
            ':RFS',
            ':TrafficCapture',
            ':TrafficCapture:dockerSolution',
    ]
    if (!(project.path in excludedProjectPaths)) {
        publishing {
            publications {
                mavenJava(MavenPublication) {
                    versionMapping {
                        allVariants {
                            // Test fixtures are published as a separate jar in maven
                            // This ensures dependencies that are only declared in test
                            // fixtures have a version number in the pom
                            if (project.plugins.hasPlugin('java-test-fixtures')) {
                                fromResolutionOf('testFixturesRuntimeClasspath')
                            }
                            fromResolutionResult()
                        }
                    }

                    from components.java
                    artifact javadocJar
                    artifact sourcesJar

                    pom {
                        name = project.name
                        description = 'Everything opensearch migrations'
                        url = 'http://github.com/opensearch-project/opensearch-migrations'

                        licenses {
                            license {
                                name = 'The Apache License, Version 2.0'
                                url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                            }
                        }
                        developers {
                            developer {
                                name = "OpenSearch"
                                url = "https://github.com/opensearch-project/opensearch-migrations"
                            }
                        }
                        scm {
                            connection = "scm:git@github.com:opensearch-project/opensearch-migrations.git"
                            developerConnection = "scm:git@github.com:opensearch-project/opensearch-migrations.git"
                            url = "git@github.com:opensearch-project/opensearch-migrations.git"
                        }
                    }

                    pom.withXml {
                        def pomFile = asNode()

                        // Find all dependencies in the POM file
                        def dependencies = pomFile.dependencies.dependency

                        // Iterate over each dependency and check if the version is missing
                        dependencies.each { dependency ->
                            def version = dependency.version.text()

                            if (version == null || version.trim().isEmpty() || version.trim() == 'unspecified') {
                                def groupId = dependency.groupId.text()
                                def artifactId = dependency.artifactId.text()
                                throw new GradleException("Dependency ${groupId}:${artifactId} is missing a version in the pom.xml")
                            }
                        }
                    }

                    // Suppress POM metadata warnings for test fixtures
                    suppressPomMetadataWarningsFor('testFixturesApiElements')
                    suppressPomMetadataWarningsFor('testFixturesRuntimeElements')
                }
            }
            repositories {
                maven { url = "${rootProject.buildDir}/repository"}
                maven {
                    url "https://aws.oss.sonatype.org/content/repositories/snapshots"
                    name = 'staging'
                }
            }
        }
    }

    // Utility task to allow copying required libraries into a 'dependencies' folder for security scanning
    tasks.register('copyDependencies', Sync) {
        duplicatesStrategy = DuplicatesStrategy.WARN

        from configurations.runtimeClasspath
        into "${buildDir}/dependencies"
    }

    def testsWithJacoco = project.tasks.withType(Test).matching { it.jacoco && it.jacoco.enabled }
    jacocoTestReport {
        dependsOn = testsWithJacoco
        executionData.from testsWithJacoco*.jacoco.destinationFile
        reports {
            xml.required = true
        }
    }
}

tasks.register('jacocoAggregateReport', JacocoReport) {
    group = 'Verification'
    description = 'Generates an aggregate report from exec files in build/jacocoMerged/*.exec over the whole project'

    // Find all merged .exec files
    executionData.setFrom(fileTree(dir: "${buildDir}", includes: [
            "jacocoMerged/**/*.exec"
    ]))

    // Get all subprojects with Java plugin
    def javaProjects = subprojects.findAll { it.plugins.hasPlugin('java') }

    // Collect all class directories from Java subprojects
    classDirectories.setFrom(
            files(javaProjects.collect { project ->
                project.sourceSets.main.output.classesDirs.filter { dir ->
                    !dir.path.contains('captureProtobufs') &&
                            !dir.path.contains('trafficCaptureProxyServerTest')
                }
            })
    )

    // Collect all source directories from Java subprojects
    sourceDirectories.setFrom(
            files(javaProjects.collect { project ->
                project.sourceSets.main.allSource.srcDirs
            })
    )

    reports {
        xml.required = true
        xml.destination file("${buildDir}/reports/jacoco/mergedReport/jacocoMergedReport.xml")
        html.required = true
        html.destination file("${buildDir}/reports/jacoco/mergedReport/html")
    }
}

gradle.projectsEvaluated {
    List<Task> isolatedTestsTasks = []
    List<Task> sharedProcessTestsTasks = []
    subprojects { subproject ->
        subproject.tasks.withType(Test).all { task ->
            if (task.name == "isolatedTest") {
                isolatedTestsTasks.add(task)
            } else {
                sharedProcessTestsTasks.add(task)
            }
        }
    }
    isolatedTestsTasks.sort { task -> task.project.name }

    // Create a sequential dependency chain
    Task previousTask = null
    isolatedTestsTasks.each { task ->
        sharedProcessTestsTasks.forEach {task.mustRunAfter(it) }
        if (previousTask != null) {
            task.mustRunAfter(previousTask)
        }
        previousTask = task
    }

    tasks.register("allTests") {
        dependsOn sharedProcessTestsTasks
        dependsOn isolatedTestsTasks
    }
}

task mergeJacocoReports {
    def jacocoReportTasks = subprojects.collect { it.tasks.withType(JacocoReport).matching { it.name == "jacocoTestReport" } }.flatten()
    dependsOn jacocoReportTasks

    // Create a Sync task to collect all exec files
    def syncJacocoExecFiles = tasks.create("syncJacocoExecFiles", Sync) {
        from jacocoReportTasks.collect { it.executionData }
        into "${buildDir}/jacocoMerged/"
        duplicatesStrategy = DuplicatesStrategy.FAIL
    }

    // Make sure sync task runs after all report tasks
    syncJacocoExecFiles.mustRunAfter jacocoReportTasks
    dependsOn syncJacocoExecFiles

    // Finalize with jacocoAggregateReport
    finalizedBy jacocoAggregateReport
}

task listPublishedArtifacts {
    doLast {
        subprojects.each { proj ->
            def publishingExtension = proj.extensions.findByType(PublishingExtension)
            if (publishingExtension) {
                publishingExtension.publications.each { publication ->
                    if (publication instanceof MavenPublication) {
                        println "${publication.groupId}.${publication.artifactId}"
                    }
                }
            }
        }
    }
}

tasks.register("listTestTasksAsJson") {
    doLast {
        def testTasks = []

        subprojects.each { subproject ->
            def projectPath = subproject.path

            // Collect test tasks without JaCoCo enabled
            subproject.tasks.withType(Test).findAll {
                !(it.extensions.findByType(JacocoTaskExtension)?.enabled ?: false)
            }.each {
                testTasks << "${projectPath}:${it.name}"
            }

            // Add jacocoTestReport if any test task has JaCoCo enabled
            if (subproject.tasks.withType(Test).any {
                it.extensions.findByType(JacocoTaskExtension)?.enabled ?: false
            }) {
                testTasks << "${projectPath}:jacocoTestReport"
            }
        }

        // Print as a clean JSON list
        println JsonOutput.prettyPrint(JsonOutput.toJson(testTasks))
    }
}