build.gradle

import com.github.jk1.license.render.*

apply plugin: 'build-dashboard'
apply plugin: 'com.github.jk1.dependency-license-report'

allprojects {
    apply plugin: 'eclipse'
    apply plugin: 'project-report'
    apply plugin: 'com.github.jk1.dependency-license-report'
    apply plugin: "net.ossindex.audit"
}

def vfsExclude =  {
    exclude group: 'org.apache.hadoop'
    exclude group: 'org.apache.jackrabbit'
}

buildscript {
    repositories {
        if (project.hasProperty('local')) {
            mavenLocal()
        }
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
        maven { url 'http://repository.activeeon.com/content/groups/proactive/'}
        maven {
            url "https://repo.jenkins-ci.org/releases/"
        }
    }

    dependencies {
        classpath 'org.ow2.proactive:documentation:1.0.0-SNAPSHOT'
        classpath 'org.ow2.proactive:gradle-serialver:2.2'
        classpath "com.diffplug.gradle.spotless:spotless:2.4.0"
        classpath "org.ow2.proactive:coding-rules:1.0.0"
        classpath 'com.github.jk1:gradle-license-report:1.7'
        classpath "gradle.plugin.net.ossindex:ossindex-gradle-plugin:0.4.11"
        delete "gradle/ext"
        ant.unjar src: configurations.classpath.find { it.name.startsWith("coding-rules") }, dest: 'gradle/ext'
    }
}

ext.serialver = programmingSerialver

subprojects {
    apply plugin: 'java'
    apply plugin: 'maven'
    apply from: "$rootDir/gradle/ext/coding-format.gradle"

    group = 'org.objectweb.proactive'
    version = programmingVersion

    sourceCompatibility = JavaVersion.VERSION_1_7
    targetCompatibility = JavaVersion.VERSION_1_7

    compileJava.options.compilerArgs << '-Xlint:-options' // remove warning about bootstrap class path


    audit {
         failOnError = false
         rateLimitAsError = false
         cache = System.getProperty("java.io.tmpdir") + File.separator + "ossindex.cache"
    }

    rootProject.buildscript.repositories.each {
        repositories.add(it)
    }

    uploadArchives {
        repositories {
            mavenDeployer {
                snapshotRepository(url: "http://repository.activeeon.com/content/repositories/snapshots/") {
                    authentication(userName: "${System.getProperty('nexusUsername')}",
                            password: "${System.getProperty('nexusPassword')}")
                }
                repository(url: "http://repository.activeeon.com/content/repositories/releases/") {
                    authentication(userName: "${System.getProperty('nexusUsername')}",
                            password: "${System.getProperty('nexusPassword')}")
                }
            }
        }
    }

    dependencies {
        compile 'ch.qos.reload4j:reload4j:1.2.25'
        testCompile 'junit:junit:4.12'
    }

    task serialver(type: serialver.InsertSerialVersionUIDTask) {
        serialver = rootProject.serialver
        overwrite = false
        forceUIDOnException = true
    }

    jar {
        manifest {
            attributes("Implementation-Title": "ProActive",
                    "Implementation-Version": version,
                    "Implementation-Vendor": "Activeeon - OASIS - INRIA Sophia Antipolis",
                    "Implementation-URL": "http://proactive.inria.fr"
            )
        }
    }
}

ext.hasGcc = {
    try {
        def p = "gcc --version".execute(); p.waitFor(); p.exitValue() == 0
    } catch (e) {
        false
    }
}()

ext.isLinux = System.getProperty("os.name").toLowerCase().contains("linux")
ext.isMac = System.getProperty("os.name").toLowerCase().contains("mac")

class StubTask extends JavaExec {
    @InputFiles
    def input = project.sourceSets.main.java.srcDirs
    @OutputFiles
    def output = project.fileTree(project.sourceSets.main.output.classesDir.parent)

    def StubTask() {
        project.configurations { stubClasspath }
        project.dependencies { stubClasspath project.project(':programming-build-utils') }
        this.dependsOn project.project(':programming-build-utils').jar
        this.dependsOn project.classes
        project.jar.dependsOn this

        def stubClasspath = (project.configurations.stubClasspath + project.sourceSets.main.runtimeClasspath).files
        environment << [CLASSPATH: stubClasspath.join(File.pathSeparator)]
        setMain('ant.AntStubGenerator$Main')
        setArgs([input.toArray()[0], project.sourceSets.main.output.classesDir])
        logging.captureStandardOutput LogLevel.INFO
    }

    def setClasses(List classes) {
        setArgs(getArgs() + classes)
    }
}

task clean << {
    delete "$rootDir/dist"
}

project(':programming-util') {
    dependencies {
        compile(
                project(':programming-annotation'),
        )
        testCompile(
                'commons-io:commons-io:2.14.0'
        )

    }
}

project(':programming-build-utils') {
    apply plugin: 'groovy'
    dependencies {
        compile gradleApi()
        compile 'ant:ant:1.7.0'
        compile 'commons-cli:commons-cli:1.3.1'
        compile "ch.qos.reload4j:reload4j:1.2.25"
        compile 'org.jvnet.winp:winp:1.28'
    }
}

project(':programming-core') {

    dependencies {
        def jettyVersion = "9.4.53.v20231009"
        compile(
                "org.eclipse.jetty:jetty-server:${jettyVersion}",
                "org.eclipse.jetty:jetty-servlet:${jettyVersion}",
                "org.eclipse.jetty:jetty-xml:${jettyVersion}",

                // Patched trilead-ssh2 used in Jenkins
                'org.json:json:20231013',
                'org.jenkins-ci:trilead-ssh2:build-217-jenkins-27',
                'com.google.protobuf:protobuf-java:3.16.3',

                'commons-cli:commons-cli:1.3.1',
                'org.javassist:javassist:3.18.2-GA',

                'xerces:xercesImpl:2.12.2',

                'com.google.guava:guava:32.0.1-jre',

                project(':programming-annotation'),
                project(':programming-util')
        )
    }


    task stub(type: StubTask) {
        classes = ['org.objectweb.proactive.core.util.wrapper.BooleanMutableWrapper',
                   'org.objectweb.proactive.core.util.wrapper.BooleanWrapper',
                   'org.objectweb.proactive.core.util.wrapper.DoubleMutableWrapper',
                   'org.objectweb.proactive.core.util.wrapper.DoubleWrapper',
                   'org.objectweb.proactive.core.util.wrapper.FloatMutableWrapper',
                   'org.objectweb.proactive.core.util.wrapper.FloatWrapper',
                   'org.objectweb.proactive.core.util.wrapper.GenericTypeWrapper',
                   'org.objectweb.proactive.core.util.wrapper.IntMutableWrapper',
                   'org.objectweb.proactive.core.util.wrapper.IntWrapper',
                   'org.objectweb.proactive.core.util.wrapper.LongMutableWrapper',
                   'org.objectweb.proactive.core.util.wrapper.LongWrapper',
                   'org.objectweb.proactive.core.util.wrapper.StringMutableWrapper',
                   'org.objectweb.proactive.core.util.wrapper.StringWrapper',

                   'org.objectweb.proactive.core.runtime.ProActiveRuntime',
                   'org.objectweb.proactive.core.body.UniversalBody',
                   'org.objectweb.proactive.core.jmx.util.JMXNotificationListener',
                   'org.objectweb.proactive.core.util.log.remote.ProActiveLogCollector',
                   'org.objectweb.proactive.core.jmx.ProActiveConnection',
                   'org.objectweb.proactive.core.jmx.server.ProActiveServerImpl']
    }
    serialver.dependsOn stub
    test {
        forkEvery 1
        systemProperties << ['proactive.classloading.useHTTP': false]
    }

    // to get rid of warning about sun internal api usage
    compileJava.options.compilerArgs << '-XDignore.symbol.file'
    compileJava.options.compilerArgs << '-Xlint:unchecked'
}

project('programming-extensions') {
    subprojects {
        dependencies {
            compile(
                    project(':programming-util')
            )
        }
    }
}

project('programming-extensions:programming-extension-amqp') {
    dependencies {
        compile(
                project(':programming-core'),
                'com.rabbitmq:amqp-client:3.5.3',
        )
    }
}

project('programming-extensions:programming-extension-pamr') {
    dependencies {
        compile(
                project(':programming-core')
        )
    }
}

project('programming-extensions:programming-extension-annotation') {
    dependencies {
        compile files("${System.properties['java.home']}/../lib/tools.jar")
        compile (
            project(':programming-core')
        )
    }
}

def vfs2RuntimeDependencies = [
        'commons-net:commons-net:3.9.0',
        'commons-httpclient:commons-httpclient:3.1',
        'com.github.mwiede:jsch:0.2.9',
        'org.slf4j:slf4j-api:1.7.36']

project('programming-extensions:programming-extension-dataspaces-common') {
    dependencies {
        compile (
                project(':programming-util'),
                'org.springframework:spring-core:4.3.30.RELEASE',
                'com.google.guava:guava:32.0.1-jre'
        )
        compile 'org.apache.commons:commons-vfs2:2.7.0', vfsExclude
    }
}

project('programming-extensions:programming-extension-vfsprovider') {
    dependencies {
        compile(
                project(':programming-core'),
                project(':programming-extensions:programming-extension-annotation'),
                project(':programming-extensions:programming-extension-dataspaces-common')
        )

        // in order to enable s3 support, run for example ./gradlew build -Ps3
        compile 'org.apache.commons:commons-vfs2:2.7.0', vfsExclude
        compile 'com.github.mwiede:jsch:0.2.9'
        compile 'commons-io:commons-io:2.14.0'
        if (rootProject.hasProperty('s3')) {
            compile 'com.github.abashev:vfs-s3:4.3.4'
        }
        testCompile 'org.apache.commons:commons-vfs2:2.7.0:tests'
        runtime vfs2RuntimeDependencies

    }
    test {
        systemProperties << ['proactive.classloading.useHTTP': false]
    }
    task stub(type: StubTask) {
        classes = ['org.objectweb.proactive.extensions.vfsprovider.protocol.FileSystemServer',
                   'org.objectweb.proactive.extensions.vfsprovider.server.FileSystemServerImpl']
    }
    serialver.dependsOn stub
}

project('programming-extensions:programming-extension-dataspaces') {
    dependencies {
        compile(
                project(':programming-core'),
                project(':programming-extensions:programming-extension-vfsprovider'),
                project(':programming-extensions:programming-extension-dataspaces-common'),
                project(':programming-util'),
                'com.google.guava:guava:32.0.1-jre'
        )
        compile 'org.apache.commons:commons-vfs2:2.7.0', vfsExclude
        testCompile(
                project(':programming-extensions:programming-extension-vfsprovider').sourceSets.test.output,
                project(':programming-extensions:programming-extension-pamr'),
                'commons-io:commons-io:2.14.0',
                'org.hamcrest:hamcrest-library:1.3'
        )
        runtime vfs2RuntimeDependencies
    }
    test {
        forkEvery 1
        systemProperties << ['proactive.classloading.useHTTP': false]
        systemProperties << ['java.security.policy': file('$rootDir/compile/proactive.java.policy').absolutePath]
    }
    task stub(type: StubTask) {
        classes = ['org.objectweb.proactive.extensions.dataspaces.core.naming.NamingService']
    }
    serialver.dependsOn stub
}

project('programming-extensions:programming-extension-gcmdeployment') {
    dependencies {
        compile(
                project(':programming-core'),
                'commons-cli:commons-cli:1.3.1',
                project(':programming-extensions:programming-extension-dataspaces')
        )
    }
    task stub(type: StubTask) {
        classes = ['org.objectweb.proactive.extensions.gcmdeployment.GCMApplication.GCMApplicationImpl',
                   'org.objectweb.proactive.extensions.gcmdeployment.core.GCMVirtualNodeImpl']
    }
    serialver.dependsOn stub
}

project('programming-extensions:programming-extension-pnp') {
    dependencies {
        compile(
                project(':programming-core'),
                'io.netty:netty:3.10.6.Final',
                'com.google.guava:guava:32.0.1-jre',
                'org.apache.commons:commons-collections4:4.4'
        )
    }
}

project('programming-extensions:programming-extension-pnpssl') {
    dependencies {
        compile(
                project(':programming-core'),
                'io.netty:netty:3.10.6.Final',
                'org.bouncycastle:bcprov-jdk15to18:1.77',
                'org.bouncycastle:bcprov-ext-jdk15to18:1.77',

                project(':programming-extensions:programming-extension-pnp')
        )
    }
}

project('programming-extensions:programming-extension-processbuilder') {
    dependencies {
        compile(
                project(':programming-core'),
                'net.java.dev.jna:jna:5.13.0',
                'net.java.dev.jna:jna-platform:5.13.0'
        )
        testCompile 'commons-io:commons-io:2.14.0'
    }

    if (hasGcc) {
        task suer
        build.dependsOn suer
        if (isLinux) {
            def configureSuer = { task, arch ->
                buildDir.mkdirs()
                task.ignoreExitValue = true
                task.inputs.file "${projectDir}/src/main/c/suer.c"
                task.outputs.file "${buildDir}/suer$arch"
                task.commandLine 'gcc'
                task.args "-m$arch", '-o', "${buildDir}/suer$arch", "${projectDir}/src/main/c/suer.c", '-lutil', '-lpthread'
            }
            task(suer64, type: Exec) { task -> configureSuer(task, '64') }
            task(suer32, type: Exec) { task -> configureSuer(task, '32') }
            suer.dependsOn suer64, suer32
        }
        if (isMac) {
            task(suermac64, type: Exec) {
                buildDir.mkdirs()
                ignoreExitValue = true
                inputs.file "${projectDir}/src/main/c/suermac.c"
                outputs.file "${buildDir}/suermac64"
                commandLine 'gcc'
                args "-m64", '-o', "${buildDir}/suermac64", "${projectDir}/src/main/c/suermac.c"
            }
            suer.dependsOn suermac64
        }
    }

    test {
        if (project.hasProperty('runasme.user')) {
            systemProperties << ['runasme.user': project.property('runasme.user')]
        }
        if (project.hasProperty('runasme.pwd')) {
            systemProperties << ['runasme.pwd': project.property('runasme.pwd')]
        }
        if (project.hasProperty('runasme.key.path')) {
            systemProperties << ['runasme.key.path': project.property('runasme.key.path')]
        }

        systemProperties << ['proactive.home': rootDir.absolutePath]
    }
}

project(':programming-test') {
    dependencies {
        testCompile(
                'commons-io:commons-io:2.14.0',
                'org.apache.commons:commons-vfs2:2.7.0',
                'org.apache.commons:commons-vfs2-jackrabbit2:2.7.0',

                project(':programming-annotation'),
                project(':programming-core'),
                project(':programming-extensions').subprojects,

                files("${rootDir}/lib/node/sigar/sigar-1.7.0-proactive.jar")
        )
        testRuntime fileTree(dir: "${rootDir}/lib/node/sigar/", exclude: "*.jar")
        testRuntime 'org.slf4j:slf4j-reload4j:1.7.36'
    }

    def testConfiguration = { Test task ->
        task.with {
            ignoreFailures = project.hasProperty('ignoreTestFailures') ? project.property('ignoreTestFailures').toBoolean() : false
            forkEvery 1
            testLogging {
                exceptionFormat = 'full'
            }
            beforeTest { descriptor ->
                logger.lifecycle("Running: " + descriptor)
            }

            if (project.hasProperty('runasme.user')) {
                systemProperties << ['runasme.user': project.property('runasme.user')]
            }
            if (project.hasProperty('runasme.pwd')) {
                systemProperties << ['runasme.pwd': project.property('runasme.pwd')]
            }
            if (project.hasProperty('runasme.key.path')) {
                systemProperties << ['runasme.key.path': project.property('runasme.key.path')]
            }
            systemProperties << ['proactive.home': rootDir.absolutePath]
            systemProperties << ['proactive.runtime.ping': false]
            systemProperties << ['java.security.policy': file('src/test/resources/proactive.java.policy').absolutePath]
            dependsOn 'copyToLib'
            dependsOn '::ProActiveJar'
        }
    }

    task functionalTest(type: Test, group: 'ProActive')
    functionalTest.configure testConfiguration
    functionalTest.configure {
        include 'functionalTests/**'
        include 'gcmdeployment/**'
        exclude '**/TestHeartbeat*'
    }

    def protocols = ['rmi', 'pnp', 'pamr', 'pnps', 'rmissh', 'http']
    protocols.each { protocol ->
        def testProtocol = task "functionalTest-$protocol"(type: Test)
        testProtocol.configure testConfiguration
        testProtocol.configure {
            include 'functionalTests/**'
            exclude '**/TestHeartbeat*'
            reports.junitXml.destination file("${reports.junitXml.destination}/$protocol")
            reports.html.destination file("${reports.html.destination}/$protocol")
            systemProperties << ['proactive.communication.protocol': protocol]
            systemProperties << ['proactive.pamr.router.address': 'localhost']
            systemProperties << ['proactive.pamr.router.port': 0]
        }
    }
    task "functionalTest-all"(dependsOn: protocols.collect { "functionalTest-$it" })

    task pamrHeartbeatTest(type: Test, group: 'ProActive') {
        include '**/TestHeartbeat*'

        systemProperties << ['-Djdwp.port': 5550]
        jvmArgs '-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5550'
    }

    task performanceTest(type: Test, group: 'ProActive')
    performanceTest.configure testConfiguration
    performanceTest.configure {
        include 'performanceTests/**'
    }

    // disable test, use allTest to run the tests
    task(allTest).dependsOn pamrHeartbeatTest, functionalTest, performanceTest
    test.enabled = false

    // for the test nodes to have the ProActive jars
    task copyToLib(type: Copy) {
        from configurations.testRuntime
        into "$buildDir/dist/lib"
    }
}

project(':doc').subprojects {
    apply plugin: 'documentation'
    documentation.outputName = project.name
    documentation.docDir = 'src'
    documentation.sharedDir = '../shared'
    documentation.snippetsStart = rootProject.projectDir
}

apply from: 'dist.gradle'

licenseReport {
    configurations = ['runtime']
    renderers = [new InventoryHtmlReportRenderer()]
}