corda/node/build.gradle

plugins {
    id 'com.google.cloud.tools.jib' version '0.9.4'
}

apply plugin: 'kotlin'
// Java Persistence API support: create no-arg constructor
// see: http://stackoverflow.com/questions/32038177/kotlin-with-jpa-default-constructor-hell
apply plugin: 'kotlin-jpa'
apply plugin: 'java'
apply plugin: 'net.corda.plugins.quasar-utils'
apply plugin: 'net.corda.plugins.publish-utils'
apply plugin: 'com.jfrog.artifactory'

description 'Corda node modules'

ext {
    Properties constants = new Properties()
    file("$rootDir/constants.properties").withInputStream { constants.load(it) }

    jolokia_version = constants.getProperty('jolokiaAgentVersion')
}

//noinspection GroovyAssignabilityCheck
configurations {
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
    
    slowIntegrationTestCompile.extendsFrom testCompile
    slowIntegrationTestRuntimeOnly.extendsFrom testRuntimeOnly

    jdkRt
    deterministic
}

sourceSets {
    integrationTest {
        kotlin {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/kotlin')
        }
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test/java')
        }
        resources {
            srcDir file('src/integration-test/resources')
        }
    }
    slowIntegrationTest {
        kotlin {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test-slow/kotlin')
        }
        java {
            compileClasspath += main.output + test.output
            runtimeClasspath += main.output + test.output
            srcDir file('src/integration-test-slow/java')
        }
        resources {
            srcDir file('src/integration-test-slow/resources')
        }
    }
}

jib.container {
  mainClass = "net.corda.node.Corda"
  args = ['--log-to-console', '--no-local-shell', '--config-file=/config/node.conf']
  // The Groovy string needs to be converted to a `java.lang.String` below.
  jvmFlags = ['-Xmx1g', "-javaagent:/app/libs/quasar-core-${quasar_version}.jar".toString()]
}

// Use manual resource copying of log4j2.xml rather than source sets.
// This prevents problems in IntelliJ with regard to duplicate source roots.
processResources {
    from file("$rootDir/config/dev/log4j2.xml")
    from file("$rootDir/config/dev/jolokia-access.xml")
}

processTestResources {
    from file("$rootDir/config/test/jolokia-access.xml")
}

// To find potential version conflicts, run "gradle htmlDependencyReport" and then look in
// build/reports/project/dependencies/index.html for green highlighted parts of the tree.

dependencies {
    compile project(':node-api')
    compile project(':client:rpc')
    compile project(':tools:shell')
    compile project(':tools:cliutils')
    compile project(':common-validation')
    compile project(':common-configuration-parsing')
    compile project(':common-logging')

    // Backwards compatibility goo: Apps expect confidential-identities to be loaded by default.
    // We could eventually gate this on a target-version check.
    compile project(':confidential-identities')

    // Log4J: logging framework (with SLF4J bindings)
    compile "org.apache.logging.log4j:log4j-slf4j-impl:${log4j_version}"
    compile "org.apache.logging.log4j:log4j-web:${log4j_version}"
    compile "org.slf4j:jul-to-slf4j:$slf4j_version"

    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
    runtimeOnly "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
    compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test:$kotlin_version"

    compile "com.google.guava:guava:$guava_version"

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

    // For async logging
    compile "com.lmax:disruptor:$disruptor_version"

    // Artemis: for reliable p2p message queues.
    // TODO: remove the forced update of commons-collections and beanutils when artemis updates them
    compile "org.apache.commons:commons-collections4:${commons_collections_version}"
    compile "commons-beanutils:commons-beanutils:${beanutils_version}"
    compile "org.apache.activemq:artemis-server:${artemis_version}"
    compile "org.apache.activemq:artemis-core-client:${artemis_version}"
    runtime("org.apache.activemq:artemis-amqp-protocol:${artemis_version}") {
        // Gains our proton-j version from core module.
        exclude group: 'org.apache.qpid', module: 'proton-j'
    }

    // Manifests: for reading stuff from the manifest file
    compile "com.jcabi:jcabi-manifests:$jcabi_manifests_version"

    // Coda Hale's Metrics: for monitoring of key statistics
    compile "io.dropwizard.metrics:metrics-jmx:$metrics_version"

    // TypeSafe Config: for simple and human friendly config files.
    compile "com.typesafe:config:$typesafe_config_version"

    // Sandbox for deterministic contract verification
    compile "net.corda.djvm:corda-djvm:$djvm_version"
    compile project(':serialization-djvm')
    compile(project(':node:djvm')) {
        transitive = false
    }
    jdkRt "net.corda:deterministic-rt:$deterministic_rt_version"
    deterministic project(path: ':core-deterministic', configuration: 'deterministicArtifacts')
    deterministic project(path: ':serialization-deterministic', configuration: 'deterministicArtifacts')
    deterministic project(':serialization-djvm:deserializers')
    deterministic project(':node:djvm')
    deterministic "org.slf4j:slf4j-nop:$slf4j_version"

    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}"

    // Unit testing helpers.
    testCompile "org.assertj:assertj-core:${assertj_version}"
    testCompile project(':node-driver')
    testCompile project(':test-utils')
    testCompile project(':client:jfx')
    testCompile project(':finance:contracts')
    testCompile project(':finance:workflows')

    // sample test schemas
    testCompile project(path: ':finance:contracts', configuration: 'testArtifacts')

    // For H2 database support in persistence
    compile "com.h2database:h2:$h2_version"

    // SQL connection pooling library
    compile "com.zaxxer:HikariCP:${hikari_version}"

    // Hibernate: an object relational mapper for writing state objects to the database automatically.
    compile "org.hibernate:hibernate-core:$hibernate_version"
    compile "org.hibernate:hibernate-java8:$hibernate_version"

    // OkHTTP: Simple HTTP library.
    compile "com.squareup.okhttp3:okhttp:$okhttp_version"

    // Apache Shiro: authentication, authorization and session management.
    compile "org.apache.shiro:shiro-core:${shiro_version}"

    //Picocli for command line interface
    compile "info.picocli:picocli:$picocli_version"

    // Integration test helpers
    integrationTestCompile "junit:junit:$junit_version"
    integrationTestCompile "org.assertj:assertj-core:${assertj_version}"
    
    // BFT-Smart dependencies
    compile 'com.github.bft-smart:library:master-v1.1-beta-g6215ec8-87'
    compile 'commons-codec:commons-codec:1.13'

    // Java Atomix: RAFT library
    compile 'io.atomix.copycat:copycat-client:1.2.3'
    compile 'io.atomix.copycat:copycat-server:1.2.3'
    compile 'io.atomix.catalyst:catalyst-netty:1.1.2'

    // Jetty dependencies for NetworkMapClient test.
    // Web stuff: for HTTP[S] servlets
    testCompile "org.eclipse.jetty:jetty-servlet:${jetty_version}"
    testCompile "org.eclipse.jetty:jetty-webapp:${jetty_version}"
    testCompile "javax.servlet:javax.servlet-api:${servlet_version}"

    // Jersey for JAX-RS implementation for use in Jetty
    testCompile "org.glassfish.jersey.core:jersey-server:${jersey_version}"
    testCompile "org.glassfish.jersey.containers:jersey-container-servlet-core:${jersey_version}"
    testCompile "org.glassfish.jersey.containers:jersey-container-jetty-http:${jersey_version}"

    // Jolokia JVM monitoring agent, required to push logs through slf4j
    compile "org.jolokia:jolokia-jvm:${jolokia_version}:agent"
    // Optional New Relic JVM reporter, used to push metrics to the configured account associated with a newrelic.yml configuration. See https://mvnrepository.com/artifact/com.palominolabs.metrics/metrics-new-relic
    compile "com.palominolabs.metrics:metrics-new-relic:${metrics_new_relic_version}"

    // Adding native SSL library to allow using native SSL with Artemis and AMQP
    compile "io.netty:netty-tcnative-boringssl-static:$tcnative_version"

    // Required by JVMAgentUtil (x-compatible java 8 & 11 agent lookup mechanism)
    compile files("${System.properties['java.home']}/../lib/tools.jar")
    
    // Byteman for runtime (termination) rules injection on the running node
    // Submission tool allowing to install rules on running nodes
    slowIntegrationTestCompile "org.jboss.byteman:byteman-submit:4.0.3"
    // The actual Byteman agent which should only be in the classpath of the out of process nodes
    slowIntegrationTestCompile "org.jboss.byteman:byteman:4.0.3"

    testCompile(project(':test-cli'))
    testCompile(project(':test-utils'))

    slowIntegrationTestCompile sourceSets.main.output
    slowIntegrationTestCompile sourceSets.test.output
    slowIntegrationTestCompile configurations.compile
    slowIntegrationTestCompile configurations.testCompile
    slowIntegrationTestRuntime configurations.runtime
    slowIntegrationTestRuntime configurations.testRuntime

    testCompile project(':testing:cordapps:dbfailure:dbfworkflows')
}

tasks.withType(JavaCompile) {
    // Resolves a Gradle warning about not scanning for pre-processors.
    options.compilerArgs << '-proc:none'
}

tasks.withType(Test) {
    if (JavaVersion.current() == JavaVersion.VERSION_11) {
        jvmArgs '-Djdk.attach.allowAttachSelf=true'
    }
    systemProperty 'deterministic-rt.path', configurations.jdkRt.asPath
    systemProperty 'deterministic-sources.path', configurations.deterministic.asPath
}

task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    maxParallelForks = (System.env.CORDA_NODE_INT_TESTING_FORKS == null) ? 1 : "$System.env.CORDA_NODE_INT_TESTING_FORKS".toInteger()
}

task slowIntegrationTest(type: Test) {
    testClassesDirs = sourceSets.slowIntegrationTest.output.classesDirs
    classpath = sourceSets.slowIntegrationTest.runtimeClasspath
    maxParallelForks = 1
}

// quasar exclusions upon agent code instrumentation at run-time
quasar {
    excludeClassLoaders.addAll(
            'net.corda.djvm.**'
    )
    excludePackages.addAll(
            "antlr**",
            "com.codahale**",
            "com.fasterxml.**",
            "com.github.benmanes.caffeine.**",
            "com.google.**",
            "com.lmax.**",
            "com.zaxxer.**",
            "djvm**",
            "net.bytebuddy**",
            "io.github.classgraph**",
            "io.netty*",
            "liquibase**",
            "net.corda.djvm**",
            "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**")
}

jar {
    baseName 'corda-node'
    manifest {
        attributes('Corda-Deterministic-Runtime': configurations.jdkRt.singleFile.name)
        attributes('Corda-Deterministic-Classpath': configurations.deterministic.collect { it.name }.join(' '))
    }
}

publish {
    name jar.baseName
}

test {
    maxHeapSize = "3g"
    maxParallelForks = (System.env.CORDA_NODE_TESTING_FORKS == null) ? 1 : "$System.env.CORDA_NODE_TESTING_FORKS".toInteger()
}