corda/core/build.gradle

apply plugin: 'org.jetbrains.kotlin.jvm'
apply plugin: 'org.jetbrains.kotlin.plugin.jpa'
apply plugin: 'net.corda.plugins.quasar-utils'
apply plugin: 'net.corda.plugins.api-scanner'
apply plugin: 'corda.common-publishing'

description 'Corda core'

sourceSets {
    obfuscator
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly

    smokeTestCompile.extendsFrom compile
    smokeTestRuntimeOnly.extendsFrom runtimeOnly
}

dependencies {
    implementation "io.opentelemetry:opentelemetry-api:${open_telemetry_version}"
    compileOnly project(':opentelemetry')

    testImplementation sourceSets.obfuscator.output
    testImplementation "org.junit.jupiter:junit-jupiter-api:${junit_jupiter_version}"
    testImplementation "junit:junit:$junit_version"
    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:${junit_vintage_version}"
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_version}"
    testRuntimeOnly "org.junit.platform:junit-platform-launcher:${junit_platform_version}"

    testImplementation "commons-fileupload:commons-fileupload:$fileupload_version"

    // Guava: Google test library (collections test suite)
    testImplementation "com.google.guava:guava-testlib:$guava_version"

    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
    testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin_version"

    // Hamkrest, for fluent, composable matchers
    testImplementation "com.natpryce:hamkrest:$hamkrest_version"

    // SLF4J: commons-logging bindings for a SLF4J back end
    implementation "org.slf4j:jcl-over-slf4j:$slf4j_version"
    implementation "org.slf4j:slf4j-api:$slf4j_version"

    // AssertJ: for fluent assertions for testing
    testImplementation "org.assertj:assertj-core:${assertj_version}"

    // Guava: Google utilities library.
    implementation "com.google.guava:guava:$guava_version"

    // For caches rather than guava
    implementation "com.github.ben-manes.caffeine:caffeine:$caffeine_version"

    // RxJava: observable streams of events.
    implementation "io.reactivex:rxjava:$rxjava_version"
    
    implementation "org.apache.commons:commons-lang3:$commons_lang3_version"

    // Java ed25519 implementation. See https://github.com/str4d/ed25519-java/
    implementation "net.i2p.crypto:eddsa:$eddsa_version"

    // Bouncy castle support needed for X509 certificate manipulation
    implementation "org.bouncycastle:bcprov-jdk18on:${bouncycastle_version}"
    testImplementation "org.bouncycastle:bcpkix-jdk18on:${bouncycastle_version}"

    // required to use @Type annotation
    implementation "org.hibernate:hibernate-core:$hibernate_version"

    // FastThreadLocal
    implementation "io.netty:netty-common:$netty_version"

    implementation group: "io.github.classgraph", name: "classgraph", version: class_graph_version

    testImplementation "org.ow2.asm:asm:$asm_version"

    // JDK11: required by Quasar at run-time
    testRuntimeOnly "com.esotericsoftware:kryo:$kryo_version"
    testRuntimeOnly "org.slf4j:slf4j-simple:$slf4j_version"

    testImplementation "org.mockito.kotlin:mockito-kotlin:$mockito_kotlin_version"
    testImplementation "org.mockito:mockito-core:$mockito_version"
    testImplementation "org.assertj:assertj-core:$assertj_version"
    testImplementation "com.natpryce:hamkrest:$hamkrest_version"
    testImplementation 'org.hamcrest:hamcrest-library:2.1'
}

// TODO Consider moving it to quasar-utils in the future (introduced with PR-1388)
tasks.register('copyQuasarJar', Copy) {
    from configurations.quasar
    into "$project.rootProject.projectDir/lib"
    rename { filename -> "quasar.jar" }
}

jar {
    finalizedBy(copyQuasarJar)
    archiveBaseName = 'corda-core'
    archiveClassifier = ''

    manifest {
        attributes('Add-Opens': 'java.base/java.net java.base/java.nio')
    }
}

configurations {
    testArtifacts.extendsFrom testRuntimeClasspath
}

processTestResources {
    inputs.files(jar)
    into("zip") {
        from(jar) {
            rename { "core.jar" }
        }
    }
}

compileTestJava {
    options.compilerArgs += [
            '--add-exports', 'java.base/sun.security.util=ALL-UNNAMED',
            '--add-exports', 'java.base/sun.security.x509=ALL-UNNAMED'
    ]
}

test {
    jvmArgs += [
            '--add-exports', 'java.base/sun.security.util=ALL-UNNAMED',
            '--add-exports', 'java.base/sun.security.x509=ALL-UNNAMED'
    ]
    maxParallelForks = (System.env.CORDA_CORE_TESTING_FORKS == null) ? 1 :  "$System.env.CORDA_CORE_TESTING_FORKS".toInteger()
}

tasks.register('testJar', Jar) {
    dependsOn testClasses
    classifier "tests"
    from sourceSets.test.output
}

// quasar exclusions upon agent code instrumentation at run-time
quasar {
    excludePackages.addAll(
            "antlr**",
            "com.codahale**",
            "com.fasterxml.**",
            "com.github.benmanes.caffeine.**",
            "com.google.**",
            "com.lmax.**",
            "com.zaxxer.**",
            "net.bytebuddy**",
            "io.github.classgraph**",
            "io.netty*",
            "liquibase**",
            "net.i2p.crypto.**",
            "nonapi.io.github.classgraph.**",
            "org.apiguardian.**",
            "org.bouncycastle**",
            "org.codehaus.**",
            "org.h2**",
            "org.hibernate**",
            "org.jboss.**",
            "org.objenesis**",
            "org.w3c.**",
            "org.xml**",
            "org.yaml**",
            "rx**",
            "io.opentelemetry.**")
}

scanApi {
    excludeClasses = [
        // Kotlin should probably have declared this class as "synthetic".
        "net.corda.core.Utils\$toFuture\$1\$subscription\$1"
    ]
}

tasks.register("writeTestResources", JavaExec) {
    classpath sourceSets.obfuscator.output
    classpath sourceSets.obfuscator.runtimeClasspath
    main 'net.corda.core.internal.utilities.TestResourceWriter'
    args new File(sourceSets.test.resources.srcDirs.first(), "zip").toString()
}

artifacts {
    testArtifacts testJar
}

publishing {
    publications {
        maven(MavenPublication) {
            artifactId 'corda-core'
            artifact(testJar)
            artifact(jar)
        }
    }
}