build.gradle

import org.opensearch.gradle.test.RestIntegTestTask
import org.opensearch.gradle.testclusters.OpenSearchCluster

import groovy.xml.XmlParser
import java.nio.file.Paths
import java.util.concurrent.Callable
import java.util.stream.Collectors

buildscript {
  ext {
    opensearch_version = System.getProperty("opensearch.version", "3.0.0-SNAPSHOT")
    isSnapshot = "true" == System.getProperty("build.snapshot", "true")
    buildVersionQualifier = System.getProperty("build.version_qualifier", "")
    version_tokens = opensearch_version.tokenize('-')
    opensearch_build = version_tokens[0] + '.0'
    if (buildVersionQualifier) {
      opensearch_build += "-${buildVersionQualifier}"
    }
    opensearch_build_snapshot = opensearch_build + '-SNAPSHOT'
    if (isSnapshot) {
      opensearch_build += "-SNAPSHOT"
    }
  }

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

  dependencies {
    classpath "org.opensearch.gradle:build-tools:${opensearch_version}"
  }
}


plugins {
  id "de.undercouch.download" version "5.3.0"
  id 'com.diffplug.spotless' version '6.25.0'
  id 'checkstyle'
}

apply plugin: 'java'
apply plugin: 'idea'
apply plugin: 'eclipse'
apply plugin: 'opensearch.opensearchplugin'
apply plugin: 'opensearch.pluginzip'
apply plugin: 'opensearch.rest-test'
apply plugin: 'opensearch.repositories'

def pluginName = 'query-insights'
def pluginDescription = 'OpenSearch Query Insights plugin'
def projectPath = 'org.opensearch'
def pathToPlugin = 'plugin.insights'
def pluginClassName = 'QueryInsightsPlugin'

configurations {
  zipArchive
}

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

publishing {
    publications {
        pluginZip(MavenPublication) { publication ->
            pom {
              name = pluginName
              description = pluginDescription
              groupId = "org.opensearch.plugin"
              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-plugin-template-java"
                }
              }
            }
        }
    }
  repositories {
    maven {
      name = "Snapshots"
      url = "https://aws.oss.sonatype.org/content/repositories/snapshots"
      credentials {
        username "$System.env.SONATYPE_USERNAME"
        password "$System.env.SONATYPE_PASSWORD"
      }
    }
  }
}

checkstyle {
  toolVersion = '10.12.1'
  showViolations true
  configDirectory.set(rootProject.file("config/checkstyle/"))
}

spotless {
  java {
    target fileTree('.') {
      include '**/*.java'
      exclude '**/build/**', '**/build-*/**'
    }
    removeUnusedImports()
    importOrder()
    eclipse().configFile rootProject.file('config/formatterConfig.xml')
    trimTrailingWhitespace()
    endWithNewline()
  }
}

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

// This requires an additional Jar not published as part of build-tools
loggerUsageCheck.enabled = false

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

allprojects {
  group 'org.opensearch'
  version = opensearch_version.tokenize('-')[0] + '.0'
  if (buildVersionQualifier) {
    version += "-${buildVersionQualifier}"
  }
  if (isSnapshot) {
    version += "-SNAPSHOT"
  }
}

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

ext {
  getSecurityPluginDownloadLink = { ->
    var repo = "https://aws.oss.sonatype.org/content/repositories/snapshots/org/opensearch/plugin/" +
      "opensearch-security/$opensearch_build_snapshot/"
    var metadataFile = Paths.get(projectDir.toString(), "build", "maven-metadata.xml").toAbsolutePath().toFile()
    download.run {
      src repo + "maven-metadata.xml"
      dest metadataFile
    }
    def metadata = new XmlParser().parse(metadataFile)
    def securitySnapshotVersion = metadata.versioning.snapshotVersions[0].snapshotVersion[0].value[0].text()

    return repo + "opensearch-security-${securitySnapshotVersion}.zip"
  }

  var projectAbsPath = projectDir.getAbsolutePath()
  File downloadedSecurityPlugin = Paths.get(projectAbsPath, 'bin', 'opensearch-security-snapshot.zip').toFile()

  configureSecurityPlugin = { OpenSearchCluster cluster ->

    cluster.getNodes().forEach { node ->
      var creds = node.getCredentials()
      if (creds.isEmpty()) {
        creds.add(Map.of('useradd', 'admin', '-p', 'admin'))
      } else {
        creds.get(0).putAll(Map.of('useradd', 'admin', '-p', 'admin'))
      }
    }

    // add a check to avoid re-downloading multiple times during single test run
    if (!downloadedSecurityPlugin.exists()) {
      download.run {
        src getSecurityPluginDownloadLink()
        dest downloadedSecurityPlugin
      }
    } else {
      println "Security Plugin File Already Exists"
    }

    // Config below including files are copied from security demo configuration
    ['esnode.pem', 'esnode-key.pem', 'root-ca.pem'].forEach { file ->
      File local = Paths.get(projectAbsPath, 'bin', file).toFile()
      download.run {
        src "https://raw.githubusercontent.com/opensearch-project/security/main/bwc-test/src/test/resources/security/" + file
        dest local
        overwrite false
      }
      cluster.extraConfigFile file, local
    }
    [
      // config copied from security plugin demo configuration
      'plugins.security.ssl.transport.pemcert_filepath' : 'esnode.pem',
      'plugins.security.ssl.transport.pemkey_filepath' : 'esnode-key.pem',
      'plugins.security.ssl.transport.pemtrustedcas_filepath' : 'root-ca.pem',
      'plugins.security.ssl.transport.enforce_hostname_verification' : 'false',
      // https is disabled to simplify test debugging
      'plugins.security.ssl.http.enabled' : 'false',
      'plugins.security.ssl.http.pemcert_filepath' : 'esnode.pem',
      'plugins.security.ssl.http.pemkey_filepath' : 'esnode-key.pem',
      'plugins.security.ssl.http.pemtrustedcas_filepath' : 'root-ca.pem',
      'plugins.security.allow_unsafe_democertificates' : 'true',
      'plugins.security.unsupported.inject_user.enabled': 'true',
      'plugins.security.allow_default_init_securityindex' : 'true',
      'plugins.security.authcz.admin_dn' : 'CN=kirk,OU=client,O=client,L=test,C=de',
      'plugins.security.audit.type' : 'internal_opensearch',
      'plugins.security.enable_snapshot_restore_privilege' : 'true',
      'plugins.security.check_snapshot_restore_write_privileges' : 'true',
      'plugins.security.restapi.roles_enabled' : '["all_access", "security_rest_api_access", "query_insights_full_access"]',
      'plugins.security.system_indices.enabled' : 'true'
    ].forEach { name, value ->
      cluster.setting name, value
    }

    cluster.plugin provider((Callable<RegularFile>) (() -> (RegularFile) (() -> downloadedSecurityPlugin)))
  }
}

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

tasks.named("check").configure { dependsOn(integTest) }

integTest {
  useCluster testClusters.integTest
  // 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'
  }
  systemProperty "cluster.names",
    getClusters().stream().map(cluster -> cluster.getName()).collect(Collectors.joining(","))

  dependsOn project.tasks.bundlePlugin
  testLogging {
    events "passed", "skipped", "failed"
  }
  afterTest { desc, result ->
    logger.quiet "${desc.className}.${desc.name}: ${result.resultType} ${(result.getEndTime() - result.getStartTime())/1000}s"
  }
  systemProperty 'tests.security.manager', 'false'
  systemProperty 'project.root', project.projectDir.absolutePath
  // Set default query size limit
  systemProperty 'defaultQuerySizeLimit', '10000'
  // Tell the test JVM if the cluster JVM is running under a debugger so that tests can use longer timeouts for
  // requests. The 'doFirst' delays reading the debug setting on the cluster till execution time.
  doFirst {
    systemProperty 'cluster.debug', getDebug()
    getClusters().forEach { cluster ->

      String allTransportSocketURI = cluster.nodes.stream().flatMap { node ->
        node.getAllTransportPortURI().stream()
      }.collect(Collectors.joining(","))
      String allHttpSocketURI = cluster.nodes.stream().flatMap { node ->
        node.getAllHttpSocketURI().stream()
      }.collect(Collectors.joining(","))

      systemProperty "tests.rest.${cluster.name}.http_hosts", "${-> allHttpSocketURI}"
      systemProperty "tests.rest.${cluster.name}.transport_hosts", "${-> allTransportSocketURI}"
    }

    systemProperty "https", "false"
  }
  if (System.getProperty("test.debug") != null) {
    jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005'
  }
  if (System.getProperty("security.enabled") == "true" || System.getProperty("https") == "true") {
    // Exclude the ITs when security is enabled, because they executed in another task (:integTestWithSecurity)
    exclude 'org/opensearch/plugin/insights/**/*IT.class'
  }
}

tasks.named("integTest").configure {
  it.dependsOn(project.tasks.named("bundlePlugin"))
}

testClusters.all {
    testDistribution = "INTEG_TEST"
    // This installs our plugin into the testClusters
    plugin(project.tasks.bundlePlugin.archiveFile)
}

run {
    useCluster testClusters.integTest
}

check.dependsOn spotlessCheck
check.dependsOn jacocoTestReport

task integTestWithSecurity(type: RestIntegTestTask) {
  useCluster testClusters.integTestWithSecurity

  systemProperty "cluster.names",
    getClusters().stream().map(cluster -> cluster.getName()).collect(Collectors.joining(","))

  getClusters().forEach { cluster ->
    configureSecurityPlugin(cluster)
  }

  dependsOn project.tasks.bundlePlugin
  testLogging {
    events "passed", "skipped", "failed"
  }
  afterTest { desc, result ->
    logger.quiet "${desc.className}.${desc.name}: ${result.resultType} ${(result.getEndTime() - result.getStartTime())/1000}s"
  }

  systemProperty 'tests.security.manager', 'false'
  systemProperty 'project.root', project.projectDir.absolutePath

  // Set default query size limit
  systemProperty 'defaultQuerySizeLimit', '10000'

  // Tell the test JVM if the cluster JVM is running under a debugger so that tests can use longer timeouts for
  // requests. The 'doFirst' delays reading the debug setting on the cluster till execution time.
  doFirst {
    systemProperty 'cluster.debug', getDebug()
    getClusters().forEach { cluster ->

      String allTransportSocketURI = cluster.nodes.stream().flatMap { node ->
        node.getAllTransportPortURI().stream()
      }.collect(Collectors.joining(","))
      String allHttpSocketURI = cluster.nodes.stream().flatMap { node ->
        node.getAllHttpSocketURI().stream()
      }.collect(Collectors.joining(","))

      systemProperty "tests.rest.${cluster.name}.http_hosts", "${-> allHttpSocketURI}"
      systemProperty "tests.rest.${cluster.name}.transport_hosts", "${-> allTransportSocketURI}"
    }

    systemProperty "https", "false"
    systemProperty "user", "admin"
    systemProperty "password", "admin"
  }

  if (System.getProperty("test.debug") != null) {
    jvmArgs '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005'
  }

  filter {
    includeTestsMatching 'org.opensearch.plugin.insights.*IT'
  }
}

// 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)
    }
}