build.gradle

/*
 * Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

import org.elasticsearch.gradle.testclusters.TestClusterConfiguration

import java.util.concurrent.TimeUnit
import java.util.function.Predicate

buildscript {
    ext {
        es_version = System.getProperty("es.version", "7.10.2")
        kotlin_version = System.getProperty("kotlin.version", "1.3.72")
    }

    repositories {
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }
        // For local publish dependency
        mavenLocal()
    }

    dependencies {
        classpath "org.elasticsearch.gradle:build-tools:${es_version}"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlin_version}"
        classpath "org.jetbrains.kotlin:kotlin-allopen:${kotlin_version}"
        classpath "io.gitlab.arturbosch.detekt:detekt-gradle-plugin:1.0.0-RC15"
        classpath "org.jacoco:org.jacoco.agent:0.8.5"
    }
}

plugins {
    id 'nebula.ospackage' version "8.3.0"
    id "com.dorongold.task-tree" version "1.5"
}

apply plugin: 'java'
apply plugin: 'jacoco'
apply plugin: 'idea'
apply plugin: 'elasticsearch.esplugin'
apply plugin: 'elasticsearch.testclusters'
apply plugin: 'elasticsearch.rest-test'
apply plugin: 'io.gitlab.arturbosch.detekt'
apply plugin: 'org.jetbrains.kotlin.jvm'
apply plugin: 'org.jetbrains.kotlin.plugin.allopen'

configurations.all {
    if (it.state != Configuration.State.UNRESOLVED) return
    resolutionStrategy {
        force "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}"
        force "org.jetbrains.kotlin:kotlin-stdlib-common:${kotlin_version}"
        force 'junit:junit:4.13.1'
        force 'commons-beanutils:commons-beanutils:1.9.4'
        force 'com.google.guava:guava:30.0-jre'
        force 'com.puppycrawl.tools:checkstyle:8.29'
        force 'commons-codec:commons-codec:1.13'
        force 'org.apache.logging.log4j:log4j:2.13.2'
        force 'org.apache.logging.log4j:log4j-core:2.13.2'
        force 'org.apache.logging.log4j:log4j-api:2.13.2'
        force 'org.apache.httpcomponents:httpclient:4.5.13'
        force 'org.apache.httpcomponents:httpclient-osgi:4.5.13'
        force 'org.apache.httpcomponents.client5:httpclient5:5.0.3'
        force 'org.apache.httpcomponents.client5:httpclient5-osgi:5.0.3'
        force 'com.fasterxml.jackson.core:jackson-databind:2.11.4'
        force 'com.fasterxml.jackson.core:jackson-core:2.11.4'
        force 'com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.11.4'
        force 'org.yaml:snakeyaml:1.26'
        force 'org.codehaus.plexus:plexus-utils:3.0.24'
    }
}

def usingRemoteCluster = System.properties.containsKey('tests.rest.cluster') || System.properties.containsKey('tests.cluster')
def usingMultiNode = project.properties.containsKey('numNodes')
// Only apply jacoco test coverage if we are running a local single node cluster
if (!usingRemoteCluster && !usingMultiNode) {
    apply from: 'build-tools/esplugin-coverage.gradle'
}
check.dependsOn jacocoTestReport

esplugin {
    name 'opendistro-index-management'
    description 'Open Distro Index Management Plugin'
    classname 'com.amazon.opendistroforelasticsearch.indexmanagement.IndexManagementPlugin'
    extendedPlugins = ['opendistro-job-scheduler']
}

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

allOpen {
    annotation("com.amazon.opendistroforelasticsearch.indexmanagement.util.OpenForTesting")
}

configurations {
    ktlint
}

detekt {
    config = files("detekt.yml")
    buildUponDefaultConfig = true
}

configurations.testCompile {
    exclude module: "securemock"
}

ext {
    projectSubstitutions = [:]
    opendistroVersion = "${version}"
    isSnapshot = "true" == System.getProperty("build.snapshot", "true")
    licenseFile = rootProject.file('LICENSE')
    noticeFile = rootProject.file('NOTICE')
}

group = "com.amazon.opendistroforelasticsearch"
version = "${opendistroVersion}.0"

dependencies {
    compileOnly "org.elasticsearch:elasticsearch:${es_version}"
    compileOnly "com.amazon.opendistroforelasticsearch:opendistro-job-scheduler-spi:1.13.0.0"
    compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlin_version}"
    compile "org.jetbrains.kotlin:kotlin-stdlib-common:${kotlin_version}"
    compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
    compile "org.jetbrains:annotations:13.0"
    compile "com.amazon.opendistroforelasticsearch:notification:1.13.1.0"
    compile "com.amazon.opendistroforelasticsearch:common-utils:1.13.0.0"
    compile "com.github.seancfoley:ipaddress:5.3.3"
    compile "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.11.4"
    compile "commons-codec:commons-codec:1.13"
    compileOnly "org.apache.logging.log4j:log4j:2.13.2"

    testCompile "org.elasticsearch.test:framework:${es_version}"
    testCompile "org.jetbrains.kotlin:kotlin-test:${kotlin_version}"
    testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:2.2.0"
    testCompile "org.mockito:mockito-core:2.23.0"

    ktlint "com.pinterest:ktlint:0.33.0"
}

repositories {
    // TODO: remove mavenLocal once notification is published to maven
    mavenLocal()
}

if (isSnapshot) {
    version += "-SNAPSHOT"
}

plugins.withId('java') {
    sourceCompatibility = targetCompatibility = "1.8"
}

plugins.withId('org.jetbrains.kotlin.jvm') {
    compileKotlin.kotlinOptions.jvmTarget = compileTestKotlin.kotlinOptions.jvmTarget = "1.8"
}

javadoc.enabled = false // turn off javadoc as it barfs on Kotlin code
licenseHeaders.enabled = true
dependencyLicenses.enabled = false
thirdPartyAudit.enabled = false
loggerUsageCheck.enabled = false
validateNebulaPom.enabled = false

def es_tmp_dir = rootProject.file('build/private/es_tmp').absoluteFile
es_tmp_dir.mkdirs()

def securityEnabled = System.getProperty("security", "false") == "true"
afterEvaluate {
    testClusters.integTest.nodes.each { node ->
        def plugins = node.plugins
        def firstPlugin = plugins.get(0)
        plugins.remove(0)
        plugins.add(firstPlugin)

        if (securityEnabled) {
            node.extraConfigFile("kirk.pem", file("src/test/resources/security/kirk.pem"))
            node.extraConfigFile("kirk-key.pem", file("src/test/resources/security/kirk-key.pem"))
            node.extraConfigFile("esnode.pem", file("src/test/resources/security/esnode.pem"))
            node.extraConfigFile("esnode-key.pem", file("src/test/resources/security/esnode-key.pem"))
            node.extraConfigFile("root-ca.pem", file("src/test/resources/security/root-ca.pem"))
            node.setting("opendistro_security.ssl.transport.pemcert_filepath", "esnode.pem")
            node.setting("opendistro_security.ssl.transport.pemkey_filepath", "esnode-key.pem")
            node.setting("opendistro_security.ssl.transport.pemtrustedcas_filepath", "root-ca.pem")
            node.setting("opendistro_security.ssl.transport.enforce_hostname_verification", "false")
            node.setting("opendistro_security.ssl.http.enabled", "true")
            node.setting("opendistro_security.ssl.http.pemcert_filepath", "esnode.pem")
            node.setting("opendistro_security.ssl.http.pemkey_filepath", "esnode-key.pem")
            node.setting("opendistro_security.ssl.http.pemtrustedcas_filepath", "root-ca.pem")
            node.setting("opendistro_security.allow_unsafe_democertificates", "true")
            node.setting("opendistro_security.allow_default_init_securityindex", "true")
            node.setting("opendistro_security.authcz.admin_dn", "CN=kirk,OU=client,O=client,L=test,C=de")
            node.setting("opendistro_security.audit.type", "internal_elasticsearch")
            node.setting("opendistro_security.enable_snapshot_restore_privilege", "true")
            node.setting("opendistro_security.check_snapshot_restore_write_privileges", "true")
            node.setting("opendistro_security.restapi.roles_enabled", "[\"all_access\", \"security_rest_api_access\"]")
            node.setting("opendistro_security.system_indices.enabled", "true")
            node.setting("opendistro_security.system_indices.indices", "[\".opendistro-ism-config\"]")
        }
    }
}

test {
    systemProperty 'tests.security.manager', 'false'
}

File repo = file("$buildDir/testclusters/repo")
def _numNodes = findProperty('numNodes') as Integer ?: 1
testClusters.integTest {
    plugin(project.tasks.bundlePlugin.archiveFile)
    testDistribution = "OSS"
    // 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 elasticsearch JVM
    // since we also support multi node integration tests we increase debugPort per node
    if (System.getProperty("cluster.debug") != null) {
        def debugPort = 5005
        nodes.forEach { node ->
            node.jvmArgs("-agentlib:jdwp=transport=dt_socket,server=n,suspend=y,address=*:${debugPort}")
            debugPort += 1
        }
    }
    plugin(provider({
        new RegularFile() {
            @Override
            File getAsFile() { fileTree("src/test/resources/job-scheduler").getSingleFile() }
        }
    }))
    if (securityEnabled) {
        // TODO: Update the actual zip to 1.12
        plugin(provider({
            new RegularFile() {
                @Override
                File getAsFile() { fileTree("src/test/resources/security") { include "opendistro-security*" }.getSingleFile() }
            }
        }))
    }
    setting 'path.repo', repo.absolutePath
}
integTest {
    systemProperty 'tests.security.manager', 'false'
    systemProperty 'java.io.tmpdir', es_tmp_dir.absolutePath
    systemProperty 'buildDir', buildDir.path
    systemProperty "https", System.getProperty("https")
    systemProperty "security", System.getProperty("security")
    systemProperty "user", System.getProperty("user", "admin")
    systemProperty "password", System.getProperty("password", "admin")
    // 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()
        // 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 -Dcluster.debug option makes the cluster debuggable; this makes the tests debuggable
    if (System.getProperty("test.debug") != null) {
        jvmArgs '-agentlib:jdwp=transport=dt_socket,server=n,suspend=y,address=8000'
    }

    // TODO: Fix running notification test against remote cluster with security plugin installed
    if (System.getProperty("https") != null) {
        filter {
            excludeTestsMatching "com.amazon.opendistroforelasticsearch.indexmanagement.indexstatemanagement.action.NotificationActionIT"
        }
    }
}

run {
    useCluster project.testClusters.integTest
    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 ->
            if (securityEnabled) {
                // TODO: This is a bit of a hack
                LinkedHashMap<String, Predicate<TestClusterConfiguration>> waitConditions = new LinkedHashMap<>()
                cluster.waitForConditions(waitConditions, System.currentTimeMillis(), 40, TimeUnit.SECONDS, cluster)
            } else {
                cluster.waitForAllConditions()
            }
        }
    }
}

task ktlint(type: JavaExec, group: "verification") {
    description = "Check Kotlin code style."
    main = "com.pinterest.ktlint.Main"
    classpath = configurations.ktlint
    args "src/**/*.kt"
    // to generate report in checkstyle format prepend following args:
    // "--reporter=plain", "--reporter=checkstyle,output=${buildDir}/ktlint.xml"
    // see https://github.com/pinterest/ktlint#usage for more
}

check.dependsOn ktlint

task ktlintFormat(type: JavaExec, group: "formatting") {
    description = "Fix Kotlin code style deviations."
    main = "com.pinterest.ktlint.Main"
    classpath = configurations.ktlint
    args "-F", "src/**/*.kt"
}

compileKotlin { kotlinOptions.freeCompilerArgs = ['-Xjsr305=strict'] }

apply from: 'build-tools/pkgbuild.gradle'

// This IT is to simulate the situation
// when there are old version (without metadata change)
// and new version mixed in one cluster
import org.elasticsearch.gradle.test.RestIntegTestTask

def mixedClusterTest = project.tasks.create('mixedCluster', RestIntegTestTask.class)
def mixedClusterFlag = findProperty('mixed') as Boolean ?: false
println("mixed cluster flag: $mixedClusterFlag")
mixedClusterTest.dependsOn(bundlePlugin)

testClusters.mixedCluster {
    testDistribution = "OSS"
    if (_numNodes > 1) numberOfNodes = _numNodes
    getNodes().each { node ->
        node.plugin(provider({
            new RegularFile() {
                @Override
                File getAsFile() { fileTree("src/test/resources/job-scheduler").getSingleFile() }
            }
        }))

        if (mixedClusterFlag && node.name == "mixedCluster-1") {
            node.plugin(provider({
                new RegularFile() {
                    @Override
                    File getAsFile() { fileTree("src/test/resources/index-management").getSingleFile() }
                }
            }))
        } else {
            node.plugin(project.tasks.bundlePlugin.archiveFile)
        }
        node.plugins.each { println("plugin in the node: ${it.get()}") }
    }
    setting 'path.repo', repo.absolutePath
}

mixedCluster {
    systemProperty 'tests.security.manager', 'false'
    systemProperty 'tests.path.repo', repo.absolutePath
    systemProperty 'cluster.mixed', "$mixedClusterFlag"
    systemProperty 'cluster.number_of_nodes', "${_numNodes}"
}