build.gradle

/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
 * Modifications Copyright OpenSearch Contributors. See
 * GitHub history for details.
 */

 /*
 * 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.
 */

buildscript {

    ext {
        opensearch_version = System.getProperty("opensearch.version", "1.0.0")
    }
    // This isn't applying from repositories.gradle so repeating it here
    repositories {
        mavenCentral()
        mavenLocal()
        maven { url "https://plugins.gradle.org/m2/" }
        jcenter()
    }

    dependencies {
        classpath "org.opensearch.gradle:build-tools:${opensearch_version}"
        classpath 'org.ajoberstar:gradle-git:0.2.3'
    }
}

plugins {
    id 'java'
    id 'nebula.ospackage' version "8.3.0"
    id 'com.github.spotbugs' version '4.6.0'
    id 'jacoco'
    id 'com.diffplug.spotless' version '5.11.0'
}

spotbugsMain {
    excludeFilter = file("checkstyle/findbugs-exclude.xml")
    effort = 'max'
    ignoreFailures = true

    reports {
        xml.enabled = false
        html.enabled = true
    }
}

spotbugsTest {
    ignoreFailures = true
}

ext {
    opensearchVersion = '1.0.0'
    isSnapshot = "true" == System.getProperty("build.snapshot", "true")
}

group = "org.opensearch"
version = "${opensearchVersion}.0"
if (isSnapshot) {
    version += "-SNAPSHOT"
}

apply plugin: 'opensearch.opensearchplugin'

ext {
    projectSubstitutions = [:]
    licenseFile = rootProject.file('LICENSE.txt')
    noticeFile = rootProject.file('NOTICE.txt')
    gitDefaultBranch = 'main'
}

spotless {
    java {
        // only apply formatting rules to updated files
        ratchetFrom "origin/${gitDefaultBranch}"

        licenseHeaderFile(file('license-header'))
        googleJavaFormat().aosp()
        importOrder()
        removeUnusedImports()
        trimTrailingWhitespace()
        endWithNewline()

        // add support for spotless:off and spotless:on tags to exclude sections of code
        toggleOffOn()
    }
}

test {
    enabled = true
    systemProperty 'tests.security.manager', 'false'
}

licenseHeaders.enabled = true
validateNebulaPom.enabled = false


loggerUsageCheck.enabled = false

opensearchplugin {
    name 'opensearch-performance-analyzer'
    description 'OpenSearch Performance Analyzer Plugin'
    classname 'org.opensearch.performanceanalyzer.PerformanceAnalyzerPlugin'
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

compileJava {
    dependsOn spotlessApply
    JavaVersion targetVersion = JavaVersion.toVersion(targetCompatibility);
    if (targetVersion.isJava9Compatible()) {
        options.compilerArgs += ["--add-exports", "jdk.attach/sun.tools.attach=ALL-UNNAMED"]
    }
}

javadoc {
     options.addStringOption("-add-exports", "jdk.attach/sun.tools.attach=ALL-UNNAMED")
}

project.afterEvaluate {
    JavaVersion targetVersion = JavaVersion.toVersion(targetCompatibility)

    // cannot contain the first version
    // should be '8' or '11' etc.
    String version = targetVersion.toString()
    if (version.length() > 2) {
        version = targetVersion.toString().substring(2)
    }

    compileJava.options.compilerArgs.removeAll(['--release', version])
}

repositories {
    mavenCentral()
    mavenLocal()
    maven { url "https://plugins.gradle.org/m2/" }
    jcenter()
}


configurations {
    includeJars
}

tasks.withType(JavaCompile) {
    options.warnings = false
}

jacoco {
    toolVersion = "0.8.5"
}

jacocoTestReport {
    reports {
        xml.enabled true
        html.enabled true
        csv.enabled false
    }
    afterEvaluate {
        classDirectories.from = files(classDirectories.files.collect {
            fileTree(dir: it,
                    include: [
                            '**/org/opensearch/performanceanalyzer/**',
                    ],
                    exclude: [
                            '**/FaultDetectionMetricsCollector.class',
                            '**/MasterThrottlingMetricsCollector.class',
                            '**/ClusterSettingsManager.class',
                    ])
        })
    }

}

jacocoTestCoverageVerification {
    afterEvaluate {
        classDirectories.from = files(classDirectories.files.collect {
            fileTree(dir: it,
                    include: [
                            '**/org/opensearch/performanceanalyzer/**',
                    ],
                    exclude: [
                    ])
        })
    }
    violationRules {
        rule {
            limit {
                minimum = 0.6
            }
        }
    }
}


// to run coverage verification during the build (and fail when appropriate)
check.dependsOn jacocoTestCoverageVerification

checkstyleMain.enabled = false
checkstyleTest.enabled = false

dependencies {
    if (JavaVersion.current() <= JavaVersion.VERSION_1_8) {
        compile files("${System.properties['java.home']}/../lib/tools.jar")
    }

    def jacksonVersion = "2.11.4"

    configurations {
        // jarHell reports class name conflicts between securemock and mockito-core
        // has to disable one of them.
        // Need to continue exclude this group until we figure out how to get rid of
        // this exclusion with opensearch
        all*.exclude group: "org.elasticsearch", module: "securemock"
    }

    configurations.all {
       resolutionStrategy {
          force 'junit:junit:4.13.1'
          force "com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}"
          force "com.fasterxml.jackson.core:jackson-core:${jacksonVersion}"
          force "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
          force "com.fasterxml.jackson.module:jackson-module-paranamer:${jacksonVersion}"
       }
    }

    compile ('com.google.guava:guava:28.2-jre') {
        force = 'true'
    }
    compile 'org.jooq:jooq:3.10.8'
    compile 'org.apache.commons:commons-lang3:3.9'
    compile 'org.bouncycastle:bcprov-jdk15on:1.68'
    compile 'org.bouncycastle:bcpkix-jdk15on:1.68'
    compile 'org.opensearch:performanceanalyzer-rca:1.0.0.0'
    compile "com.fasterxml.jackson.core:jackson-annotations:${jacksonVersion}"
    compile "com.fasterxml.jackson.core:jackson-databind:${jacksonVersion}"
    compile "com.fasterxml.jackson.module:jackson-module-paranamer:${jacksonVersion}"
    compile(group: 'org.apache.logging.log4j', name: 'log4j-api', version: '2.11.1') {
        force = 'true'
    }
    compile(group: 'org.apache.logging.log4j', name: 'log4j-core', version: '2.11.1') {
        force = 'true'
    }

    // JDK9+ has to run powermock 2+. https://github.com/powermock/powermock/issues/888
    testCompile group: 'org.powermock', name: 'powermock-api-mockito2', version: '2.0.0'
    testCompile(group: 'org.powermock', name: 'powermock-module-junit4', version: '2.0.0') {
        exclude(group: 'org.hamcrest', module: 'hamcrest-core')
    }
    testCompile group: 'org.mockito', name: 'mockito-core', version: '2.23.0'
    // Dependency to mock final classes.
    testImplementation group: 'org.mockito', name: 'mockito-inline', version: '2.13.0'
    testCompile group: 'org.powermock', name: 'powermock-core', version: '2.0.0'
    testCompile group: 'org.powermock', name: 'powermock-api-support', version: '2.0.0'
    testCompile(group: 'org.powermock', name: 'powermock-module-junit4-common', version: '2.0.0') {
        exclude(group: 'org.hamcrest', module: 'hamcrest-core')
    }
    testCompile group: 'org.javassist', name: 'javassist', version: '3.24.0-GA'
    testCompile group: 'org.powermock', name: 'powermock-reflect', version: '2.0.0'
    //minimum byte-buddy version to be compatible with mockito-core 2.23.0 is 1.9.7+. https://github.com/mockito/mockito/issues/1606
    testCompile(group: 'net.bytebuddy', name: 'byte-buddy', version: '1.9.7') {
        force = 'true'
    }
    testCompile(group: 'net.bytebuddy', name: 'byte-buddy-agent', version: '1.9.7') {
        force = 'true'
    }
    testCompile(group: 'org.objenesis', name: 'objenesis', version: '3.0.1') {
        force = 'true'
    }
    testCompile group: 'com.google.code.gson', name: 'gson', version: '2.8.6'
}

dependencyLicenses {
    mapping from: /jackson-.*/, to: 'jackson'
}

dependencyLicenses.doFirst {
    updateShas.updateShas()
}

gradle.startParameter.excludedTaskNames += [ "forbiddenApisMain",
                                             "forbiddenApisTest",
                                             "thirdPartyAudit",
                                             "testingConventions"]
import java.nio.file.Paths
import org.ajoberstar.gradle.git.tasks.GitClone
import org.opensearch.gradle.test.RestIntegTestTask

String rcaDir
String rcaArtifactsDir

static def propEnabled(property) {
    return System.getProperty(property) != null && System.getProperty(property).toLowerCase().equals("true")
}

// The following Gradle tasks are used to create a PA/RCA enabled OpenSearch cluster
// Pass the -Dtests.enableIT property to Gradle to run ITs
/**
 * cloneGitRepo clones the performance-analyzer-rca repo if the -Dtests.enableIT=true flag is passed
 * to the Gradle JVM
 */
task cloneGitRepo(type: GitClone) {
    rcaDir = Paths.get(getProject().getBuildDir().toString(), "performance-analyzer-rca").toString()
    def destination = file(rcaDir)
    uri = "https://github.com/opensearch-project/performance-analyzer-rca.git"
    branch = gitDefaultBranch
    destinationPath = destination
    bare = false
    enabled = !destination.exists() // to clone only once
}

task buildRca() {
    dependsOn(cloneGitRepo)
    doLast {
        exec {
            workingDir("$rcaDir")
            commandLine './gradlew', 'build', '-x', 'test'
        }
        exec {
            workingDir("$rcaDir")
            commandLine './gradlew', 'publishToMavenLocal'
        }
        exec {
            def licenseDir = "$projectDir/licenses"
            workingDir("$licenseDir")
            commandLine 'rm', "performanceanalyzer-rca-1.0.0.0.jar.sha1"
        }
        exec {
            workingDir("$projectDir")
            commandLine './gradlew', 'updateShas'
        }
    }
}

task unpackRca(type: Copy) {
    dependsOn(buildRca)
    from(zipTree("$rcaDir/build/distributions/performance-analyzer-rca.zip")) {
    }
    into "$rcaDir/build/distributions"
    rcaArtifactsDir = "$rcaDir/build/distributions/performance-analyzer-rca/"
}

bundlePlugin {
    dependsOn 'cloneGitRepo'
    from("$rcaArtifactsDir/pa_config") {
        into "pa_config"
    }
    from("$rcaArtifactsDir/pa_bin") {
        into "pa_bin"
        include "performance-analyzer-agent"
    }
    from("$rcaArtifactsDir/pa_bin") {
        into "extensions"
        include "performance-analyzer-agent"
    }
    from("$rcaArtifactsDir") {
        into "performance-analyzer-rca"
    }
    from("packaging") {
        include "performance-analyzer-agent-cli"
        into "bin"
    }
    from("packaging") {
        include "deb/**", "rpm/**"
        into "install"
    }
    from('build/resources/main/') {
        include "plugin-security.policy"
    }
    exclude('tools.jar')
    from("config/opensearch-performance-analyzer") {
        into "config"
    }
}

/**
 * setupOpenSearchCluster spins up a local 2 node OpenSearch cluster using the enableRca task in the performance-analyzer-rca
 * repo. The performance-analyzer-rca repo is cloned as part of the cloneGitRepo task.
 */
task setupOpenSearchCluster() {
    dependsOn(cloneGitRepo)
    onlyIf = {
        propEnabled("tests.enableIT")
    }
    doLast {
        exec {
            workingDir(rcaDir)
            commandLine './gradlew', 'enableRca'
        }
        sleep(30000)
    }
}

/**
 * integTest is a task provided by the OpenSearch test framework, which allows us to spin up clients
 * and test API calls against a local or remote OpenSearch cluster.
 *
 * The simplest way to run this task in a way that "just works" is to invoke
 * ./gradlew integTest -Dtests.enableIT=true -Dtests.useDockerCluster=true
 * which will spin up a local 2 node OpenSearch cluster on your machine, then execute the test suite against it
 *
 * A full list of options is provided below. Check our gradle.properties file for the defaults for
 * each of these properties.
 *
 * -Dtests.rest.cluster the OpenSearch REST endpoint that test clients should hit
 * -Dtests.cluster the OpenSearch <a href="https://discuss.elastic.co/t/transport-client-vs-rest-client/13936">transport</a>
 *      endpoint that test clients should hit
 * -Dtests.enableIT a flag to enable integration testing, by default this is false
 * -Dtests.useDockerCluster if true, spin up a local 2 node cluster before executing tests
 *        NOTE: if you specify this, don't specify -Dtests.rest.cluster or -Dtests.cluster
 * -Dtests.pa.port the port number of the PerformanceAnalyzer REST endpoint
 * -Dtests.https either true or false, if true, then instantiate REST and transport clients using
 *      the https:// protocol and basic authentication via the -Dtests.user and -Dtests.password properties
 * -Dtests.user the username of the admin user, this is used in conjunction with -Dtests.https and
 *      -Dtests.password to authenticate requests in the opensearch-security context
 * -Dtests.password the password of the admin user specified by -Dtests.user
 */
task integTest(type: RestIntegTestTask) {
    onlyIf = {
        propEnabled("tests.enableIT")
    }
    if (propEnabled("tests.useDockerCluster")) {
        dependsOn(setupOpenSearchCluster)
    }
    systemProperty 'tests.security.manager', 'false'
    description = "Run integration tests against integTest cluster"
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
}

// This is afterEvaluate because the bundlePlugin ZIP task is updated afterEvaluate and changes the ZIP name to match the plugin name
afterEvaluate {
    ospackage {
        packageName = "opensearch-performance-analyzer"
        release = isSnapshot ? "0.1" : '1'
        version = "${project.version}" - "-SNAPSHOT"

        into '/usr/share/opensearch/plugins'
        from(zipTree(bundlePlugin.archivePath)) {
            into opensearchplugin.name
        }

        configurationFile '/usr/lib/systemd/system/opensearch.service'
        into('/usr/lib/systemd/system') {
            fileType CONFIG | NOREPLACE
            from "packaging/opensearch-performance-analyzer.service"
            fileMode 0644
        }
        into('/usr/share/opensearch/bin') {
            from ('packaging/performance-analyzer-agent-cli') {
                fileMode 0755
            }
        }

        user 'root'
        permissionGroup 'root'
        fileMode 0644
        dirMode 0755

        requires('opensearch', versions.opensearch, EQUAL)
        packager = 'Amazon'
        vendor = 'Amazon'
        os = 'LINUX'
        prefix '/usr'

        license 'ASL-2.0'
        maintainer 'OpenSearch <opensearch@amazon.com>'
        url 'https://opensearch.org/downloads.html'
        summary '''
         Performance Analyzer plugin for OpenSearch.
         Reference documentation can be found at https://opensearch.org/docs/.
    '''.stripIndent().replace('\n', ' ').trim()
    }

    buildRpm {
        arch = 'NOARCH'
        postInstall file('packaging/rpm/postinst')
        postUninstall file('packaging/rpm/postrm')
        dependsOn 'assemble'
        finalizedBy 'renameRpm'
        task renameRpm(type: Copy) {
            from("$buildDir/distributions")
            into("$buildDir/distributions")
            include archiveName
            rename archiveName, "${packageName}-${version}.rpm"
            doLast {
                delete file("$buildDir/distributions/$archiveName")
            }
        }
    }

    buildDeb {
        arch = 'all'
        postInstall file('packaging/deb/postinst')
        postUninstall file('packaging/deb/postrm')
        dependsOn 'assemble'
        finalizedBy 'renameDeb'
        task renameDeb(type: Copy) {
            from("$buildDir/distributions")
            into("$buildDir/distributions")
            include archiveName
            rename archiveName, "${packageName}-${version}.deb"
            doLast {
                delete file("$buildDir/distributions/$archiveName")
            }
        }
    }

    task buildPackages(type: GradleBuild) {
        tasks = ['build', 'buildRpm', 'buildDeb']
    }
}

bundlePlugin.mustRunAfter unpackRca
build.dependsOn unpackRca