corda/samples/attachment-demo/build.gradle

apply plugin: 'kotlin'
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 {
    info {
        name "Corda Attachment Demo"
        vendor "R3"
        targetPlatformVersion corda_platform_version.toInteger()
        minimumPlatformVersion 1
    }
}

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

configurations {
    integrationTestCompile.extendsFrom testCompile
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
    cordaDriver "net.corda:corda-shell:$corda_release_version"
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
    compile "net.sf.jopt-simple:jopt-simple:$jopt_simple_version"
    compile "javax.servlet:javax.servlet-api:${servlet_version}"
    compile "javax.ws.rs:javax.ws.rs-api:2.1.1"
    cordaCompile project(':client:rpc')

    // 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.
    cordaRuntime "org.slf4j:slf4j-simple:$slf4j_version"

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

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

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

    testCompile "org.assertj:assertj-core:$assertj_version"

    integrationTestCompile project(':testing:testserver')
}

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

def nodeTask = tasks.getByPath(':node:capsule:assemble')
def webTask = tasks.getByPath(':testing:testserver:testcapsule::assemble')
task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar', nodeTask, webTask]) {
    ext.rpcUsers = [['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
    }
    node {
        name "O=Notary Node,L=Zurich,C=CH"
        notary = [validating: true,
                  serviceLegalName: "O=Notary Service,L=Zurich,C=CH"
        ]
        p2pPort 10002
        cordapps = []
        rpcUsers = ext.rpcUsers
        rpcSettings {
            address "localhost:10003"
            adminAddress "localhost:10004"
        }
        extraConfig = ['h2Settings.address': 'localhost:10012']
    }
    node {
        name "O=Bank A,L=London,C=GB"
        p2pPort 10005
        cordapps = []
        rpcUsers = ext.rpcUsers
        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
        cordapps = []
        rpcUsers = ext.rpcUsers
        extraConfig = ['h2Settings.address': 'localhost:10014']
    }
}

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

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