build.gradle

buildscript {

    ext.mavenRepositories = {
        maven {
            url artifactoryMavenSnapshotRepo
            credentials {
                username mavenUser
                password mavenPassword
            }
        }
        maven {
            url artifactoryMavenRepo
            credentials {
                username mavenUser
                password mavenPassword
            }
        }
        maven {
            url "https://talend-update.talend.com/nexus/content/repositories/libraries/"
        }
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }

    repositories mavenRepositories

    dependencies {
        classpath libs.gradle.sonar.plugin
        classpath libs.gradle.release
        classpath libs.gradle.licencer
        classpath libs.gradle.jib.plugin
    }
}

import java.util.regex.Matcher
import org.gradle.plugins.ide.eclipse.model.AccessRule
import org.gradle.plugins.ide.eclipse.model.ClasspathEntry
import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry

//noinspection GroovyAssignabilityCheck
group 'org.zowe.apiml'

apply plugin: 'java-library'

apply from: 'gradle/license.gradle'
apply from: 'gradle/publish.gradle'
apply from: 'gradle/sonar.gradle'
apply from: 'gradle/coverage.gradle'
apply from: 'gradle/code-quality.gradle'
apply from: 'gradle/lite.gradle'

sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17

allprojects {
    apply plugin: 'idea'
    apply plugin: 'org.cadixdev.licenser'
    apply plugin: 'eclipse'

    repositories mavenRepositories

    version = version

    eclipse {
        classpath {
            file {
                whenMerged { classpath ->
                    for (ClasspathEntry entry : classpath.getEntries()) {
                        if (entry instanceof AbstractClasspathEntry) {
                            AbstractClasspathEntry theEntry = (AbstractClasspathEntry) entry
                            if (theEntry.path != null && theEntry.path.contains('org.eclipse.jdt.launching.JRE_CONTAINER')) {
                                theEntry.accessRules.add(new AccessRule('accessible', 'com/sun/net/httpserver/**'))
                            }
                        }
                    }
                }
            }
            downloadJavadoc = true
            downloadSources = true
        }
    }

    idea {
        module {
            //noinspection GroovyAssignabilityCheck
            outputDir file('build/classes/main')
            //noinspection GroovyAssignabilityCheck
            testOutputDir file('build/classes/test')
            downloadJavadoc = true
            downloadSources = true
        }
    }

}

configure(subprojects.findAll {it.name != 'platform'}) {
    apply plugin: 'java-library'

    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17

    test {
        useJUnitPlatform()
        jvmArgs '--add-opens=java.base/java.nio.channels.spi=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/sun.nio.ch=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/java.io=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/java.util=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/java.util.concurrent=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/java.lang.invoke=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/java.lang.reflect=ALL-UNNAMED'
        jvmArgs '--add-opens=java.base/javax.net.ssl=ALL-UNNAMED'
    }

    dependencies {
        api(platform(project(":platform")))

        testImplementation libs.junit.jupiter

        testImplementation libs.junit.platform.launcher

        //For Idea
        testImplementation libs.junit.platform.commons
        testImplementation libs.junit.platform.engine
    }
}

subprojects {
    license {
        header = rootProject.file('.licence/EPL-2.0-licence-header.txt')
        exclude '**/*.yml', '**/*.yaml', '**/*.json', '**/static', '**/*.sh', '**/*.txt', '**/*.p12', '**/*.xml', '**/*.jsp', '**/*.html', '**/*.jks', '**/*.properties'
    }

    tasks.withType(Test) {
        maxParallelForks = 1
    }
}

task buildCore(dependsOn: [':discovery-service:build', ':api-catalog-services:build', ':api-catalog-ui:build',
                           ':discoverable-client:build', ':zaas-client:build', ':apiml-sample-extension:build', ':cloud-gateway-service:build']) {
    description "Build core components"
    group "build"
}

task runAllIntegrationTests(dependsOn: ":integration-tests:runAllIntegrationTests") {
    description "Run all integration tests"
    group "Integration tests"
}

task environmentCheck(dependsOn: ":integration-tests:environmentCheck") {
    description "Environment check"
    group "Integration tests"
}

task runCITests(dependsOn: [":integration-tests:runCITests"]) {
    description "Run Integration Test Without MF Dependencies"
    group "Integration tests"
}

task runStartUpCheck(dependsOn: [":integration-tests:runStartUpCheck"]) {
    description "Run Startup check"
    group "Integration tests"
}

task runContainerTests(dependsOn: [":integration-tests:runContainerTests"]) {
    description "Run Integration Test Without MF Dependencies"
    group "Integration tests"
}

task runRegistrationTests(dependsOn: [":integration-tests:runRegistrationTests"]) {
    description "Run Integration Test verifying registration and deregistration"
    group "Integration tests"
}

task runCloudGatewayProxyTest(dependsOn: [":integration-tests:runCloudGatewayProxyTest"]) {
    description "Run tests verifying cloud gateway can route to correct gateway"
    group "Integration tests"
}

task runCloudGatewayServiceRoutingTest(dependsOn: [":integration-tests:runCloudGatewayServiceRoutingTest"]) {
    description "Run tests verifying cloud gateway can locate service and translate auth scheme"
    group "Integration tests"
}

task runOidcTests(dependsOn: [":integration-tests:runOidcTests"]) {
    description "Run tests verifying integration with oidc provider(okta)"
    group "Integration tests"
}

task runIdPrefixReplacerTests(dependsOn: [":integration-tests:runIdPrefixReplacerTests"]) {
    description "Run Integration Test verifying the service ID prefix replacer mechanism"
    group "Integration tests"
}

task publishAllVersions {
    group 'Zowe Publishing'
    description 'Publish ZIP file and SDK libraries to Zowe Artifactory'
    doLast {
        println 'Published ZIP file and libraries'
    }
}

task nodejsClean(type: Delete) {
    group = 'npm'
    if (cleanNode == 'true') {
        delete 'api-catalog-ui/tools/nodejs', 'api-catalog-ui/tools/npm', 'api-catalog-ui/tools/yarn'
        delete 'onboarding-enabler-nodejs-sample-app/tools/nodejs', 'onboarding-enabler-nodejs-sample-app/tools/npm', 'onboarding-enabler-nodejs-sample-app/tools/yarn'
    }
}


task runBaseTests(dependsOn: ":integration-tests:runBaseTests") {
    description "Run base tests"
    group "Integration tests"
}

task runZosmfAuthTest(dependsOn: ":integration-tests:runZosmfAuthTest") {
    description "Run zOSMF dependant authentication tests only"
    group "Integration tests"
}
task runZaasTest(dependsOn: ":integration-tests:runZaasTest") {
    description "Run Zaas dependant authentication tests only"
    group "Integration tests"
}

task runBaseTestsInternalPort(dependsOn: ":integration-tests:runBaseTestsInternalPort") {
    description "Run base tests on internal port"
    group "Integration tests"
}
task runCachingServiceTests(dependsOn: ":integration-tests:runCachingServiceTests") {
    description "Run caching service tests"
    group "Integration tests"
}
task runInfinispanServiceTests(dependsOn: ":integration-tests:runInfinispanServiceTests") {
    description "Run tests for caching service with infinispan storage option"
    group "Integration tests"
}
task runHATests(dependsOn: ":integration-tests:runHATests") {
    description "Run HA tests tests only"
    group "Integration tests"
}
task runChaoticHATests(dependsOn: ":integration-tests:runChaoticHATests") {
    description "Run Chaotic HA tests tests only"
    group "Integration tests"
}

clean.dependsOn nodejsClean

publishAllVersions.dependsOn publishSdkArtifacts

//-----------Release part start
apply plugin: 'net.researchgate.release'

ext.releaseScope = project.hasProperty('release.scope') ? project.getProperty('release.scope') : 'patch'

release {
    failOnCommitNeeded = true
    failOnPublishNeeded = true
    failOnSnapshotDependencies = true
    failOnUnversionedFiles = false
    failOnUpdateNeeded = true
    revertOnFail = true
    preCommitText = '[Gradle Release plugin]'
    preTagCommitMessage = '[skip ci] Before tag commit'
    tagCommitMessage = 'Release:'
    tagTemplate = 'v${version}'
    newVersionCommitMessage = 'Create new version:'
    versionPropertyFile = 'gradle.properties'

    if (releaseScope == 'minor') {
        versionPatterns = [
            /[.]*\.(\d+)\.(\d+)[.]*/: { Matcher m, Project p -> m.replaceAll(".${(m[0][1] as int) + 1}.0") }
        ]
    } else if (releaseScope == 'major') {
        versionPatterns = [
            /(\d+)\.(\d+)\.(\d+)[.]*/: { Matcher m, Project p -> m.replaceAll("${(m[0][1] as int) + 1}.0.0") }
        ]
    } else {
        versionPatterns = [
            /(\d+)([^\d]*$)/: { Matcher m, Project p -> m.replaceAll("${(m[0][1] as int) + 1}${m[0][2]}") }
        ]
    }

    scmAdapters = [
        net.researchgate.release.GitAdapter
    ]

    git {
        requireBranch.set('')
        pushToRemote.set('origin')
        pushToBranchPrefix.set('')
        commitVersionFileOnly.set(true)
        signTag.set(false)
    }
}

afterReleaseBuild.dependsOn publishAllVersions
//-----------Release part end


if (hasProperty('buildScan')) {
    buildScan {
        termsOfServiceUrl = 'https://gradle.com/terms-of-service'
        termsOfServiceAgree = 'yes'
    }
}