build.gradle

import java.nio.file.Files
import org.opensearch.gradle.testclusters.OpenSearchCluster
import org.opensearch.gradle.testclusters.StandaloneRestIntegTestTask
import org.opensearch.gradle.test.RestIntegTestTask
import org.opensearch.gradle.VersionProperties
import java.util.concurrent.Callable
import java.nio.file.Paths

buildscript {
    ext {
        opensearch_version = System.getProperty("opensearch.version", "3.0.0-alpha1-SNAPSHOT")
        buildVersionQualifier = System.getProperty("build.version_qualifier", "alpha1")
        isSnapshot = "true" == System.getProperty("build.snapshot", "true")
        version_tokens = opensearch_version.tokenize('-')
        opensearch_build = version_tokens[0] + '.0'
        plugin_no_snapshot = opensearch_build
        if (buildVersionQualifier) {
            opensearch_build += "-${buildVersionQualifier}"
            plugin_no_snapshot += "-${buildVersionQualifier}"
        }
        if (isSnapshot) {
            opensearch_build += "-SNAPSHOT"
        }
        opensearch_group = "org.opensearch"
        opensearch_no_snapshot = opensearch_build.replace("-SNAPSHOT","")
        System.setProperty('tests.security.manager', 'false')
        common_utils_version = System.getProperty("common_utils.version", opensearch_build)
        swaggerCoreVersion = "2.2.23"
        bwcVersionShort = "2.12.0"
        bwcVersion = bwcVersionShort + ".0"
        bwcOpenSearchFFDownload = 'https://ci.opensearch.org/ci/dbc/distribution-build-opensearch/' + bwcVersionShort + '/latest/linux/x64/tar/builds/' +
                'opensearch/plugins/opensearch-flow-framework-' + bwcVersion + '.zip'
        baseName = "ffBwcCluster"
        bwcFilePath = "src/test/resources/org/opensearch/flowframework/bwc/"
        bwcFlowFrameworkPath = bwcFilePath + "flowframework/"

        isSameMajorVersion = opensearch_version.split("\\.")[0] == bwcVersionShort.split("\\.")[0]
        swaggerVersion = "2.1.25"
        swaggerCoreVersion = "2.2.28"
    }

    repositories {
        mavenLocal()
        maven { url "https://aws.oss.sonatype.org/content/repositories/snapshots" }
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }
        maven { url 'https://jitpack.io' }
    }

    dependencies {
        classpath "org.opensearch.gradle:build-tools:${opensearch_version}"
        classpath "com.diffplug.spotless:spotless-plugin-gradle:7.0.2"
    }
}

plugins {
    id "de.undercouch.download" version "5.6.0"
    id "org.gradle.test-retry" version "1.6.2" apply false
    id "io.github.surpsg.delta-coverage" version "2.5.0"
}

apply plugin: 'java'
apply plugin: 'idea'
apply plugin: 'opensearch.opensearchplugin'
apply plugin: 'opensearch.yaml-rest-test'
apply plugin: 'opensearch.pluginzip'
// for formatting and license headers
apply plugin: 'com.diffplug.spotless'
apply from: 'formatter/formatting.gradle'
// for javadocs and checks spotless doesn't do
apply plugin: 'checkstyle'

def pluginName = 'opensearch-flow-framework'
def pluginDescription = 'OpenSearch plugin that enables builders to innovate AI apps on OpenSearch'
def projectPath = 'org.opensearch'
def pathToPlugin = 'flowframework'
def pluginClassName = 'FlowFrameworkPlugin'
group = "org.opensearch.flowframework"

opensearchplugin {
    name pluginName
    description pluginDescription
    classname "${projectPath}.${pathToPlugin}.${pluginClassName}"
    licenseFile rootProject.file('LICENSE')
    noticeFile rootProject.file('NOTICE')
}

dependencyLicenses.enabled = false
// This requires an additional Jar not published as part of build-tools
loggerUsageCheck.enabled = false
thirdPartyAudit.enabled = false
// Allow test cases to be named Tests without having to be inherited from LuceneTestCase.
// see https://github.com/elastic/elasticsearch/blob/323f312bbc829a63056a79ebe45adced5099f6e6/buildSrc/src/main/java/org/elasticsearch/gradle/precommit/TestingConventionsTasks.java
testingConventions.enabled = false

// No need to validate pom, as we do not upload to maven/sonatype
validateNebulaPom.enabled = false

allprojects {
    // Default to the apache license
    project.ext.licenseName = 'The Apache Software License, Version 2.0'
    project.ext.licenseUrl = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
}

publishing {
    publications {
        pluginZip(MavenPublication) { publication ->

            pom {
                name = pluginName
                description = pluginDescription
                groupId = "org.opensearch.plugin"

                withXml { XmlProvider xml ->
                    Node node = xml.asNode()
                    node.appendNode('inceptionYear', '2021')

                    Node license = node.appendNode('licenses').appendNode('license')
                    license.appendNode('name', project.licenseName)
                    license.appendNode('url', project.licenseUrl)

                    Node developer = node.appendNode('developers').appendNode('developer')
                    developer.appendNode('name', 'OpenSearch')
                    developer.appendNode('url', 'https://github.com/opensearch-project/flow-framework')
                }
            }
        }
    }

    repositories {
        maven {
            name = 'staging'
            url = "${rootProject.buildDir}/local-staging-repo"
        }
        maven {
            name = "Snapshots"
            url = "https://aws.oss.sonatype.org/content/repositories/snapshots"
            credentials {
                username "$System.env.SONATYPE_USERNAME"
                password "$System.env.SONATYPE_PASSWORD"
            }
        }
    }
}

allprojects {
    group = opensearch_group
    version = "${opensearch_build}"
}

java {
    targetCompatibility = JavaVersion.VERSION_21
    sourceCompatibility = JavaVersion.VERSION_21
}

repositories {
    mavenLocal()
    maven { url "https://aws.oss.sonatype.org/content/repositories/snapshots" }
    mavenCentral()
    maven { url "https://plugins.gradle.org/m2/" }
}

configurations {
    zipArchive
    secureIntegTestPluginArchive
}

dependencies {
    implementation "org.opensearch:opensearch:${opensearch_version}"
    api group: 'org.opensearch', name:'opensearch-ml-client', version: "${opensearch_build}"
    api(group: 'org.opensearch.client', name: 'opensearch-rest-client', version: "${opensearch_version}") {
        exclude group: "org.apache.httpcomponents.client5", module: "httpclient5"
    }
    implementation "org.apache.commons:commons-lang3:${versions.commonslang}"
    implementation "org.opensearch:common-utils:${common_utils_version}"
    implementation "com.amazonaws:aws-encryption-sdk-java:3.0.1"
    implementation "software.amazon.cryptography:aws-cryptographic-material-providers:1.9.0"
    implementation "org.dafny:DafnyRuntime:4.10.0"
    implementation "software.amazon.smithy.dafny:conversion:0.1.1"
    implementation 'org.bouncycastle:bcprov-jdk18on:1.80'
    api "org.apache.httpcomponents.core5:httpcore5:${versions.httpcore5}"
    implementation "jakarta.json.bind:jakarta.json.bind-api:3.0.1"
    implementation "org.glassfish:jakarta.json:2.0.1"
    implementation "org.eclipse:yasson:3.0.4"
    implementation "com.google.code.gson:gson:2.12.1"
    // Swagger-Parser dependencies for API consistency tests
    implementation "io.swagger.core.v3:swagger-models:${swaggerCoreVersion}"
    implementation "io.swagger.core.v3:swagger-core:${swaggerCoreVersion}"
    implementation "io.swagger.parser.v3:swagger-parser-core:${swaggerVersion}"
    implementation "io.swagger.parser.v3:swagger-parser:${swaggerVersion}"
    implementation "io.swagger.parser.v3:swagger-parser-v3:${swaggerVersion}"
    // Multi-tenant SDK Client
    implementation ("org.opensearch:opensearch-remote-metadata-sdk:${opensearch_build}") {
        exclude group: "org.apache.httpcomponents.client5", module: "httpclient5"
    }
    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4'
    testImplementation "com.fasterxml.jackson.core:jackson-annotations:${versions.jackson}"
    testImplementation "com.fasterxml.jackson.core:jackson-databind:${versions.jackson_databind}"
    testImplementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:${versions.jackson_databind}"

    // ZipArchive dependencies used for integration tests
    // Check the order in case of transitive dependencies
    zipArchive group: 'org.opensearch.plugin', name:'opensearch-job-scheduler', version: "${opensearch_build}"
    zipArchive group: 'org.opensearch.plugin', name:'opensearch-ml-plugin', version: "${opensearch_build}"
    zipArchive group: 'org.opensearch.plugin', name:'opensearch-knn', version: "${opensearch_build}"
    zipArchive group: 'org.opensearch.plugin', name:'neural-search', version: "${opensearch_build}"
    secureIntegTestPluginArchive group: 'org.opensearch.plugin', name:'opensearch-security', version: "${opensearch_build}"

    configurations.all {
        resolutionStrategy {
            force("com.google.guava:guava:33.4.0-jre") // CVE for 31.1, keep to force transitive dependencies
        }
    }
}


def opensearch_tmp_dir = rootProject.file('build/private/opensearch_tmp').absoluteFile
opensearch_tmp_dir.mkdirs()
def _numNodes = findProperty('numNodes') as Integer ?: 1

test {
    include '**/*Tests.class'
}

jacocoTestReport {
    dependsOn test
    reports {
        xml.required = true
    }
}
tasks.named("check").configure { dependsOn(jacocoTestReport) }

tasks.named("yamlRestTest").configure {
    filter {
        excludeTestsMatching "org.opensearch.flowframework.rest.*IT"
        excludeTestsMatching "org.opensearch.flowframework.bwc.*IT"
    }
}

// Set up integration tests
task integTest(type: RestIntegTestTask) {
    description = "Run tests against a cluster"
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
}
tasks.named("check").configure { dependsOn(integTest) }

integTest {

    dependsOn "bundlePlugin"
    systemProperty 'tests.security.manager', 'false'
    systemProperty 'java.io.tmpdir', opensearch_tmp_dir.absolutePath
    systemProperty('project.root', project.rootDir.absolutePath)
    systemProperty 'security.enabled', System.getProperty('security.enabled')
    var is_https = System.getProperty('https')
    var user = System.getProperty('user')
    var password = System.getProperty('password')
    // Using default admin credentials since the install_plugin_configuration script is not used to configure the security plugin
    if (System.getProperty('security.enabled') != null) {
        is_https = is_https == null ? 'true' : is_https
        user = user == null ? 'admin' : user
        password = password == null ? 'admin' : password
        System.setProperty("https", is_https)
        System.setProperty("user", user)
        System.setProperty("password", password)
    }
    systemProperty('https', is_https)
    systemProperty('user', user)
    systemProperty('password', password)

    // Only tenant aware test if set
    if (System.getProperty("tests.rest.tenantaware") == "true") {
        filter {
            includeTestsMatching "org.opensearch.flowframework.*TenantAwareIT"
        }
        systemProperty "plugins.flow_framework.multi_tenancy_enabled", "true"
        systemProperty "plugins.ml_commons.multi_tenancy_enabled", "true"
    }

    // Only rest case can run with remote cluster
    if (System.getProperty("tests.rest.cluster") != null && System.getProperty("tests.rest.tenantaware") == null) {
        filter {
            includeTestsMatching "org.opensearch.flowframework.rest.*IT"
            excludeTestsMatching "org.opensearch.flowframework.rest.*TenantAwareIT"
        }
    }

    // Exclude BWC tests, run separately
    if (System.getProperty("tests.rest.bwcsuite") == null) {
        filter {
            excludeTestsMatching "org.opensearch.flowframework.bwc.*IT"
        }
    }

    // Exclude integration tests that require security plugin
    if (System.getProperty("https") == null || System.getProperty("https") == "false") {
        filter {
            excludeTestsMatching "org.opensearch.flowframework.rest.FlowFrameworkSecureRestApiIT"
        }
    }

    // Include only secure integration tests in security enabled clusters
    if (System.getProperty("https") != null && System.getProperty("https") == "true") {
        filter {
            includeTestsMatching "org.opensearch.flowframework.rest.FlowFrameworkSecureRestApiIT"
            excludeTestsMatching "org.opensearch.flowframework.rest.FlowFrameworkRestApiIT"
            excludeTestsMatching "org.opensearch.flowframework.rest.*TenantAwareIT"
        }
    }

    // doFirst delays this block until execution time
    doFirst {
        if (System.getProperty("tests.rest.tenantaware") == "true") {
            def ymlFile = file("$buildDir/testclusters/integTest-0/config/opensearch.yml")
            if (ymlFile.exists()) {
                ymlFile.withWriterAppend {
                    writer ->
                    writer.write("\n# Set multitenancy\n")
                    writer.write("plugins.flow_framework.multi_tenancy_enabled: true\n")
                    writer.write("plugins.ml_commons.multi_tenancy_enabled: true\n")
                }
                // TODO this properly uses the remote client factory but needs a remote cluster set up
                // TODO get the endpoint from a system property
                if (System.getProperty("tests.rest.cluster") != null) {
                    ymlFile.withWriterAppend { writer ->
                        writer.write("\n# Use a remote cluster\n")
                        writer.write("plugins.flow_framework.remote_metadata_type: RemoteOpenSearch\n")
                        writer.write("plugins.flow_framework.remote_metadata_endpoint: https://127.0.0.1:9200\n")
                    }
                }
            } else {
                throw new GradleException("opensearch.yml not found at: $ymlFile")
            }
        }

        // Tell the test JVM if the cluster JVM is running under a debugger so that tests can
        // use longer timeouts for requests.
        def isDebuggingCluster = getDebug() || System.getProperty("test.debug") != null
        systemProperty 'cluster.debug', isDebuggingCluster
        // Set number of nodes system property to be used in tests
        systemProperty 'cluster.number_of_nodes', "${_numNodes}"
        // There seems to be an issue when running multi node run or integ tasks with unicast_hosts
        // not being written, the waitForAllConditions ensures it's written
        getClusters().forEach { cluster ->
            cluster.waitForAllConditions()
        }
    }

    // The --debug-jvm command-line option makes the cluster debuggable; this makes the tests debuggable
    if (System.getProperty("test.debug") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005'
    }
}

// Set up integration test clusters, installs all zipArchive dependencies and Flow Framework
testClusters.integTest {
    testDistribution = "ARCHIVE"

    // Optionally install security
    if (System.getProperty("https") != null && System.getProperty("https") == "true") {
        // Retrieve Security Plugin Zip from zipArchive
        configurations.secureIntegTestPluginArchive.asFileTree.each {
            if(it.name.contains("opensearch-security")) {
                plugin(provider(new Callable<RegularFile>(){
                        @Override
                        RegularFile call() throws Exception {
                            return new RegularFile() {
                                @Override
                                File getAsFile() {
                                    return it
                                }
                            }
                        }
                    })
                )
            }
        }

        // Using default admin credentials since the install_plugin_configuration script is not used to configure the security plugin
        getNodes().forEach { node ->
            var creds = node.getCredentials()
            if (creds.isEmpty()) {
                creds.add(Map.of('username', 'admin', 'password', 'admin'))
            } else {
                creds.get(0).putAll(Map.of('username', 'admin', 'password', 'admin'))
            }
        }

        // Config below including files are copied from security demo configuration
        ['esnode.pem', 'esnode-key.pem', 'root-ca.pem'].forEach { file ->
            File local = Paths.get(opensearch_tmp_dir.absolutePath, file).toFile()
            download.run {
                src "https://raw.githubusercontent.com/opensearch-project/security/main/bwc-test/src/test/resources/security/" + file
                dest local
                overwrite false
            }
            extraConfigFile(file, local)
        }

        // This configuration is copied from the security plugins demo install:
        // https://github.com/opensearch-project/security/blob/2.11.1.0/tools/install_demo_configuration.sh#L365-L388
        setting("plugins.security.ssl.transport.pemcert_filepath", "esnode.pem")
        setting("plugins.security.ssl.transport.pemkey_filepath", "esnode-key.pem")
        setting("plugins.security.ssl.transport.pemtrustedcas_filepath", "root-ca.pem")
        setting("plugins.security.ssl.transport.enforce_hostname_verification", "false")
        setting("plugins.security.ssl.http.enabled", "true")
        setting("plugins.security.ssl.http.pemcert_filepath", "esnode.pem")
        setting("plugins.security.ssl.http.pemkey_filepath", "esnode-key.pem")
        setting("plugins.security.ssl.http.pemtrustedcas_filepath", "root-ca.pem")
        setting("plugins.security.allow_unsafe_democertificates", "true")
        setting("plugins.security.allow_default_init_securityindex", "true")
        setting("plugins.security.unsupported.inject_user.enabled", "true")

        setting("plugins.security.authcz.admin_dn", "\n- CN=kirk,OU=client,O=client,L=test, C=de")
        setting('plugins.security.restapi.roles_enabled', '["all_access", "security_rest_api_access"]')
        setting('plugins.security.system_indices.enabled', "true")
        setting('plugins.security.system_indices.indices', '[' +
                '".plugins-ml-config", ' +
                '".plugins-ml-connector", ' +
                '".plugins-ml-model-group", ' +
                '".plugins-ml-model", ' +
                '".plugins-ml-task", ' +
                '".plugins-ml-conversation-meta", ' +
                '".plugins-ml-conversation-interactions", ' +
                '".plugins-flow-framework-config", ' +
                '".plugins-flow-framework-templates", ' +
                '".plugins-flow-framework-state"' +
                ']'
        )
        setSecure(true)
    }

    // Installs all registered zipArchive dependencies on integTest cluster nodes except security
    configurations.zipArchive.asFileTree.each {
            plugin(provider(new Callable<RegularFile>(){
                    @Override
                    RegularFile call() throws Exception {
                        return new RegularFile() {
                            @Override
                            File getAsFile() {
                                return it
                            }
                        }
                    }
                })
            )

    }

    // Install Flow Framework Plugin on integTest cluster nodes
    plugin(project.tasks.bundlePlugin.archiveFile)

    // Cluster shrink exception thrown if we try to set numberOfNodes to 1, so only apply if > 1
    if (_numNodes > 1) numberOfNodes = _numNodes

    // When running integration tests it doesn't forward the --debug-jvm to the cluster anymore
    // i.e. we have to use a custom property to flag when we want to debug OpenSearch JVM
    // since we also support multi node integration tests we increase debugPort per node
    if (System.getProperty("opensearch.debug") != null) {
        def debugPort = 5005
        nodes.forEach { node ->
            node.jvmArgs("-agentlib:jdwp=transport=dt_socket,server=n,suspend=y,address=*:${debugPort}")
            debugPort += 1
        }
    }
}

// Remote Integration Tests
task integTestRemote(type: RestIntegTestTask) {
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    var is_https = System.getProperty('https')
    var user = System.getProperty('user')
    var password = System.getProperty('password')
    // Using default admin credentials since the install_plugin_configuration script is not used to configure the security plugin
    if (System.getProperty('security.enabled') != null) {
        is_https = is_https == null ? 'true' : is_https
        user = user == null ? 'admin' : user
        password = password == null ? 'admin' : password
        System.setProperty("https", is_https)
        System.setProperty("user", user)
        System.setProperty("password", password)
    }
    systemProperty('https', is_https)
    systemProperty('user', user)
    systemProperty('password', password)
    systemProperty 'cluster.number_of_nodes', "${_numNodes}"
    systemProperty 'tests.security.manager', 'false'

    // Run tests with remote cluster only if rest case is defined
    if (System.getProperty("tests.rest.cluster") != null) {
        filter {
            includeTestsMatching "org.opensearch.flowframework.rest.*IT"
        }
    }

    // Exclude integration tests that require security plugin
    if (System.getProperty("https") == null || System.getProperty("https") == "false") {
        filter {
            excludeTestsMatching "org.opensearch.flowframework.rest.FlowFrameworkSecureRestApiIT"
        }
    }

    // Include only secure integration tests in security enabled clusters
    if (System.getProperty("https") != null && System.getProperty("https") == "true") {
        filter {
            includeTestsMatching "org.opensearch.flowframework.rest.FlowFrameworkSecureRestApiIT"
            excludeTestsMatching "org.opensearch.flowframework.rest.FlowFrameworkRestApiIT"
        }
    }
}

2.times {i ->
    testClusters {
        "${baseName}$i" {
            testDistribution = "ARCHIVE"
            versions = [bwcVersionShort, opensearch_version]
            numberOfNodes = 3
            plugin(provider(new Callable<RegularFile>(){
                @Override
                RegularFile call() throws Exception {
                    return new RegularFile() {
                        @Override
                        File getAsFile() {
                            if (new File("$project.rootDir/$bwcFilePath/flow-framework/$bwcVersion").exists()) {
                                project.delete(files("$project.rootDir/$bwcFilePath/flow-framework/$bwcVersion"))
                            }
                            project.mkdir bwcFlowFrameworkPath + bwcVersion
                            ant.get(src: bwcOpenSearchFFDownload,
                                    dest: bwcFlowFrameworkPath + bwcVersion,
                                    httpusecaches: false)
                            return fileTree(bwcFlowFrameworkPath + bwcVersion).getSingleFile()
                        }
                    }
                }
            }))
            setting 'path.repo', "${buildDir}/cluster/shared/repo/${baseName}"
            setting 'http.content_type.required', 'true'
        }
    }
}

List<Provider<RegularFile>> plugins = [
        provider(new Callable<RegularFile>(){
            @Override
            RegularFile call() throws Exception {
                return new RegularFile() {
                    @Override
                    File getAsFile() {
                        return configurations.zipArchive.asFileTree.matching{include "**/opensearch-job-scheduler-${opensearch_build}.zip"}.getSingleFile()
                    }
                }
            }
        }),
        provider(new Callable<RegularFile>(){
            @Override
            RegularFile call() throws Exception {
                return new RegularFile() {
                    @Override
                    File getAsFile() {
                        return configurations.zipArchive.asFileTree.matching{include "**/opensearch-ml-plugin-${opensearch_build}.zip"}.getSingleFile()
                    }
                }
            }
        }),
        provider(new Callable<RegularFile>(){
            @Override
            RegularFile call() throws Exception {
                return new RegularFile() {
                    @Override
                    File getAsFile() {
                        return configurations.zipArchive.asFileTree.matching{include "**/opensearch-knn-${opensearch_build}.zip"}.getSingleFile()
                    }
                }
            }
        }),
        provider(new Callable<RegularFile>(){
            @Override
            RegularFile call() throws Exception {
                return new RegularFile() {
                    @Override
                    File getAsFile() {
                        return configurations.zipArchive.asFileTree.matching{include "**/neural-search-${opensearch_build}.zip"}.getSingleFile()
                    }
                }
            }
        }),
        provider(new Callable<RegularFile>(){
            @Override
            RegularFile call() throws Exception {
                return new RegularFile() {
                    @Override
                    File getAsFile() {
                        return fileTree(bwcFilePath + "flow-framework/" + project.version).getSingleFile()
            }
                }
            }
        })
    ]

// Creates 2 test clusters with 3 nodes of the old version.
2.times {i ->
    task "${baseName}#oldVersionClusterTask$i"(type: StandaloneRestIntegTestTask) {
        onlyIf { isSameMajorVersion || (i == 1) }
        useCluster testClusters."${baseName}$i"
        filter {
            includeTestsMatching "org.opensearch.flowframework.bwc.*IT"
        }
        systemProperty 'tests.rest.bwcsuite', 'old_cluster'
        systemProperty 'tests.rest.bwcsuite_round', 'old'
        systemProperty 'tests.plugin_bwc_version', bwcVersion
        nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}$i".allHttpSocketURI.join(",")}")
        nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}$i".getName()}")
    }
}

// Upgrades one node of the old cluster to new OpenSearch version with upgraded plugin version
// This results in a mixed cluster with 2 nodes on the old version and 1 upgraded node.
// This is also used as a one third upgraded cluster for a rolling upgrade.
task "${baseName}#mixedClusterTask"(type: StandaloneRestIntegTestTask) {
    onlyIf { isSameMajorVersion }
    useCluster testClusters."${baseName}0"
    dependsOn "${baseName}#oldVersionClusterTask0"
    doFirst {
      testClusters."${baseName}0".upgradeNodeAndPluginToNextVersion(plugins)
    }
    filter {
      includeTestsMatching "org.opensearch.flowframework.bwc.*IT"
    }
    systemProperty 'tests.rest.bwcsuite', 'mixed_cluster'
    systemProperty 'tests.rest.bwcsuite_round', 'first'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}0".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}0".getName()}")
}

// Upgrades the second node to new OpenSearch version with upgraded plugin version after the first node is upgraded.
// This results in a mixed cluster with 1 node on the old version and 2 upgraded nodes.
// This is used for rolling upgrade.
task "${baseName}#twoThirdsUpgradedClusterTask"(type: StandaloneRestIntegTestTask) {
    onlyIf { isSameMajorVersion }
    dependsOn "${baseName}#mixedClusterTask"
    useCluster testClusters."${baseName}0"
    doFirst {
      testClusters."${baseName}0".upgradeNodeAndPluginToNextVersion(plugins)
    }
    filter {
      includeTestsMatching "org.opensearch.flowframework.bwc.*IT"
    }
    systemProperty 'tests.rest.bwcsuite', 'mixed_cluster'
    systemProperty 'tests.rest.bwcsuite_round', 'second'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}0".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}0".getName()}")
}

// Upgrades the third node to new OpenSearch version with upgraded plugin version after the second node is upgraded.
// This results in a fully upgraded cluster.
// This is used for rolling upgrade.
task "${baseName}#rollingUpgradeClusterTask"(type: StandaloneRestIntegTestTask) {
    onlyIf { isSameMajorVersion }
    dependsOn "${baseName}#twoThirdsUpgradedClusterTask"
    useCluster testClusters."${baseName}0"
    doFirst {
      testClusters."${baseName}0".upgradeNodeAndPluginToNextVersion(plugins)
    }
    filter {
      includeTestsMatching "org.opensearch.flowframework.bwc.*IT"
    }
    mustRunAfter "${baseName}#mixedClusterTask"
    systemProperty 'tests.rest.bwcsuite', 'mixed_cluster'
    systemProperty 'tests.rest.bwcsuite_round', 'third'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}0".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}0".getName()}")
}

// Upgrades all the nodes of the old cluster to new OpenSearch version with upgraded plugin version
// at the same time resulting in a fully upgraded cluster.
task "${baseName}#fullRestartClusterTask"(type: StandaloneRestIntegTestTask) {
    dependsOn "${baseName}#oldVersionClusterTask1"
    useCluster testClusters."${baseName}1"
    doFirst {
      testClusters."${baseName}1".upgradeAllNodesAndPluginsToNextVersion(plugins)
    }
    filter {
      includeTestsMatching "org.opensearch.flowframework.bwc.*IT"
    }
    systemProperty 'tests.rest.bwcsuite', 'upgraded_cluster'
    systemProperty 'tests.plugin_bwc_version', bwcVersion
    nonInputProperties.systemProperty('tests.rest.cluster', "${-> testClusters."${baseName}1".allHttpSocketURI.join(",")}")
    nonInputProperties.systemProperty('tests.clustername', "${-> testClusters."${baseName}1".getName()}")
}

// A bwc test suite which runs all the bwc tasks combined.
task bwcTestSuite(type: StandaloneRestIntegTestTask) {
    filter {
        excludeTestsMatching '**.*Test*'
        excludeTestsMatching '**.*IT*'
        setFailOnNoMatchingTests(false)
    }
    dependsOn tasks.named("${baseName}#mixedClusterTask")
    dependsOn tasks.named("${baseName}#rollingUpgradeClusterTask")
    dependsOn tasks.named("${baseName}#fullRestartClusterTask")
}

// test retry configuration
allprojects {
    apply plugin: "org.gradle.test-retry"
    tasks.withType(RestIntegTestTask).configureEach {
        retry {
            if (System.getenv().containsKey("CI")) {
                maxRetries = 1
                maxFailures = 4
                failOnPassedAfterRetry = false
            }
        }
    }
    // Needed for Gradle 9.0
    tasks.withType(StandaloneRestIntegTestTask).configureEach {
        testClassesDirs = sourceSets.test.output.classesDirs
        classpath = sourceSets.test.runtimeClasspath
    }
}

// Automatically sets up the integration test cluster locally
run {
    doFirst {
        // There seems to be an issue when running multi node run or integ tasks with unicast_hosts
        // not being written, the waitForAllConditions ensures it's written
        getClusters().forEach { cluster ->
            cluster.waitForAllConditions()
        }
    }

    useCluster testClusters.integTest
}

// updateVersion: Task to auto update version to the next development iteration
task updateVersion {
    onlyIf { System.getProperty('newVersion') }
    doLast {
        ext.newVersion = System.getProperty('newVersion')
        println "Setting version to ${newVersion}."
        // String tokenization to support -SNAPSHOT
        ant.replaceregexp(file:'build.gradle', match: '"opensearch.version", "\\d.*"', replace: '"opensearch.version", "' + newVersion.tokenize('-')[0] + '-SNAPSHOT"', flags:'g', byline:true)
    }
}

deltaCoverageReport {
    diffSource {
        git.compareWith("refs/remotes/origin/main")
    }

    violationRules {
        failOnViolation.set(true)
        rule(io.github.surpsg.deltacoverage.gradle.CoverageEntity.LINE) {
            minCoverageRatio.set(0.75d)
        }
        rule(io.github.surpsg.deltacoverage.gradle.CoverageEntity.BRANCH) {
            minCoverageRatio.set(0.6d)
        }
    }

    reports {
        html.set(true)
    }
}

tasks.withType(AbstractPublishToMaven) {
    def predicate = provider {
        publication.name == "pluginZip"
    }
    onlyIf("Publishing only ZIP distributions") {
        predicate.get()
    }
}