corda/samples/attachment-demo/build.gradle

apply plugin: 'org.jetbrains.kotlin.jvm'
apply plugin: 'idea'
apply plugin: 'net.corda.plugins.quasar-utils'
apply plugin: 'net.corda.plugins.cordapp'
apply plugin: 'net.corda.plugins.cordformation'

description 'Corda attachment demo'

cordapp {
    targetPlatformVersion corda_platform_version.toInteger()
}

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

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
    if (System.getProperty('excludeShell') == null) {
        cordaDriver "net.corda:corda-shell:$corda_shell_version"
    }

    cordaProvided project(':core')
    cordaProvided project(':client:rpc')

    implementation "io.reactivex:rxjava:$rxjava_version"
    implementation "net.sf.jopt-simple:jopt-simple:$jopt_simple_version"
    implementation "javax.servlet:javax.servlet-api:${servlet_version}"
    implementation "javax.ws.rs:javax.ws.rs-api:2.1.1"

    // Cordformation needs a SLF4J implementation when executing the Network
    // Bootstrapper, but Log4J doesn't shutdown completely from within Gradle.
    // Use a much simpler SLF4J implementation here instead.
    cordaBootstrapper "org.slf4j:slf4j-simple:$slf4j_version"
    cordaBootstrapper project(":node-api")

    // Corda integration dependencies
    corda project(path: ":node:capsule", configuration: 'runtimeArtifacts')
    corda project(path: ":testing:testserver:testcapsule:", configuration: 'runtimeArtifacts')

    cordapp project(':samples:attachment-demo:contracts')
    cordapp project(':samples:attachment-demo:workflows')

    testImplementation(project(':node-driver')) {
        // We already have a SLF4J implementation on our runtime classpath,
        // and we don't need another one.
        exclude group: 'org.apache.logging.log4j', module: 'log4j-slf4j-impl'
    }
    
    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 "org.assertj:assertj-core:$assertj_version"

    integrationTestImplementation project(':core')
    integrationTestImplementation project(':node')
    integrationTestImplementation project(':client:rpc')
    integrationTestImplementation project(':core-test-utils')
    integrationTestImplementation project(':testing:testserver')

    integrationTestImplementation "junit:junit:$junit_version"
}

task integrationTest(type: Test, dependsOn: []) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath

    jvmArgs test_add_opens
    jvmArgs test_add_exports
}

def nodeTask = tasks.getByPath(':node:capsule:assemble')
def webTask = tasks.getByPath(':testing:testserver:testcapsule::assemble')
configurations.cordaCordapp.canBeResolved = true
task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar', nodeTask, webTask]) {
    def users = [
            ['username': "demo", 'password': "demo", 'permissions': [
                    "StartFlow.net.corda.attachmentdemo.AttachmentDemoFlow",
                    "InvokeRpc.partiesFromName",
                    "InvokeRpc.notaryPartyFromX500Name",
                    "InvokeRpc.attachmentExists",
                    "InvokeRpc.openAttachment",
                    "InvokeRpc.uploadAttachment",
                    "InvokeRpc.internalVerifiedTransactionsFeed",
                    "InvokeRpc.startTrackedFlowDynamic",
                    "InvokeRpc.nodeInfo"]
            ]
    ]

    nodeDefaults {
        projectCordapp {
            deploy = false
        }
        cordapp project(':samples:attachment-demo:contracts')
        cordapp project(':samples:attachment-demo:workflows')
        runSchemaMigration = true
        rpcUsers = users
    }
    node {
        name "O=Notary Node,L=Zurich,C=CH"
        notary = [validating: true,
                  serviceLegalName: "O=Notary Service,L=Zurich,C=CH"
        ]
        p2pPort 10002
        rpcSettings {
            address "localhost:10003"
            adminAddress "localhost:10004"
        }
        extraConfig = ['h2Settings.address': 'localhost:10012']
    }
    node {
        name "O=Bank A,L=London,C=GB"
        p2pPort 10005
        rpcSettings {
            address "localhost:10006"
            adminAddress "localhost:10007"
        }
        extraConfig = ['h2Settings.address': 'localhost:10013']
    }
    node {
        name "O=Bank B,L=New York,C=US"
        p2pPort 10008
        rpcSettings {
            address "localhost:10009"
            adminAddress "localhost:10011"
        }
        webPort 10010
        extraConfig = ['h2Settings.address': 'localhost:10014']
    }
}

task runSender(type: JavaExec, dependsOn: jar) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'net.corda.attachmentdemo.AttachmentDemoKt'

    jvmArgs test_add_opens
    jvmArgs test_add_exports

    args '--role'
    args 'SENDER'
}

task runRecipient(type: JavaExec, dependsOn: jar) {
    classpath = sourceSets.main.runtimeClasspath
    main = 'net.corda.attachmentdemo.AttachmentDemoKt'

    jvmArgs test_add_opens
    jvmArgs test_add_exports

    args '--role'
    args 'RECIPIENT'
}