mirror of https://github.com/corda/corda.git synced 2024-12-23 14:52:29 +00:00

Andrzej Cichocki 879b1a6393 Tutorial runExampleClientRPC is now runExampleClientRPCKotlin. (#1446 )

2017-09-07 15:00:03 +01:00

28 KiB

Raw Blame History

The example CorDapp

The example CorDapp allows nodes to agree IOUs with each other. Nodes will always agree to the creation of a new IOU unless:

Its value is less than 1, or greater than 99
A node tries to issue an IOU to itself

By default, the CorDapp is deployed on 4 test nodes:

Controller, which hosts the network map service and validating notary service
NodeA
NodeB
NodeC

Because data is only propagated on a need-to-know basis, any IOUs agreed between NodeA and NodeB become "shared facts" between NodeA and NodeB only. NodeC won't be aware of these IOUs.

Downloading the example CorDapp

If you haven't already, set up your machine by following the quickstart guide <getting-set-up>. Then clone the example CorDapp from the cordapp-tutorial repository using the following command:

git clone https://github.com/corda/cordapp-tutorial

And change directories to the freshly cloned repo:

cd cordapp-tutorial

We want to work off the latest Milestone release. To enumerate all the Milestone releases, run:

git tag

And check out the latest (highest-numbered) Milestone release using:

git checkout [tag_name]

Where tag_name is the name of the tag you wish to checkout. Gradle will grab all the required dependencies for you from our public Maven repository.

Note

If you wish to build off the latest, unstable version of the codebase, follow the instructions in Using a SNAPSHOT release.

Opening the example CorDapp in IntelliJ

Let's open the example CorDapp in the IntelliJ IDE.

For those completely new to IntelliJ

Upon opening IntelliJ, a dialogue will appear:

Click open, then navigate to the folder where you cloned the cordapp-tutorial and click OK.

Next, IntelliJ will show several pop-up windows, one of which requires our attention:

Click the 'import gradle project' link. A dialogue will pop-up. Press OK. Gradle will now download all the project dependencies and perform some indexing. This usually takes a minute or so.

If the 'import gradle project' pop-up does not appear, click the small green speech bubble at the bottom-right of the IDE, or simply close and re-open IntelliJ again to make it reappear.

If you already have IntelliJ open

From the File menu, navigate to Open ... and then navigate to the directory where you cloned the cordapp-tutorial and click OK.

Project structure

The example CorDapp has the following directory structure:

.
├── LICENCE
├── README.md
├── TRADEMARK
├── build.gradle
├── config
│   ├── dev
│   │   └── log4j2.xml
│   └── test
│       └── log4j2.xml
├── doc
│   └── example_flow.plantuml
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── java-source
│   └── ...
├── kotlin-source
│   ├── build.gradle
│   └── src
│       ├── main
│       │   ├── kotlin
│       │   │   └── com
│       │   │       └── example
│       │   │           ├── api
│       │   │           │   └── ExampleApi.kt
│       │   │           ├── client
│       │   │           │   └── ExampleClientRPC.kt
│       │   │           ├── contract
│       │   │           │   └── IOUContract.kt
│       │   │           ├── flow
│       │   │           │   └── ExampleFlow.kt
│       │   │           ├── model
│       │   │           │   └── IOU.kt
│       │   │           ├── plugin
│       │   │           │   └── ExamplePlugin.kt
│       │   │           ├── schema
│       │   │           │   └── IOUSchema.kt
│       │   │           └── state
│       │   │               └── IOUState.kt
│       │   └── resources
│       │       ├── META-INF
│       │       │   └── services
│       │       │       └── net.corda.webserver.services.WebServerPluginRegistry
│       │       ├── certificates
│       │       │   ├── readme.txt
│       │       │   ├── sslkeystore.jks
│       │       │   └── truststore.jks
│       │       └── exampleWeb
│       │           ├── index.html
│       │           └── js
│       │               └── angular-module.js
│       └── test
│           └── kotlin
│               └── com
│                   └── example
│                       ├── Main.kt
│                       ├── contract
│                       │   └── IOUContractTests.kt
│                       └── flow
│                           └── IOUFlowTests.kt
├── lib
│   ├── README.txt
│   └── quasar.jar
└── settings.gradle

The most important files and directories to note are:

The root directory contains some gradle files, a README and a LICENSE
config contains log4j configs
gradle contains the gradle wrapper, which allows the use of Gradle without installing it yourself and worrying about which version is required
lib contains the Quasar jar which is required for runtime instrumentation of classes by Quasar

* kotlin-source contains the source code for the example CorDapp written in Kotlin

kotlin-source/src/main/kotlin contains the source code for the example CorDapp
kotlin-source/src/main/python contains a python script which accesses nodes via RPC
kotlin-source/src/main/resources contains the certificate store, some static web content to be served by the nodes and the WebServerPluginRegistry file
kotlin-source/src/test/kotlin contains unit tests for the contracts and flows, and the driver to run the nodes via IntelliJ

* java-source contains the same source code, but written in java. This is an aid for users who do not want to

develop in Kotlin, and serves as an example of how CorDapps can be developed in any language targeting the JVM

Running the example CorDapp

There are two ways to run the example CorDapp:

Via the terminal
Via IntelliJ

We explain both below.

Terminal: Building the example CorDapp

Return to your terminal window and make sure you are in the cordapp-tutorial directory. To build the example CorDapp use the following command:

Unix/Mac OSX: ./gradlew deployNodes
Windows: gradlew.bat deployNodes

This will package up our CorDapp source files into a plugin and automatically build four pre-configured nodes that have our CorDapp plugin installed. These nodes are meant for local testing only.

After the build process has finished, you will see the newly-build nodes in the kotlin-source/build/nodes. There will be one folder generated for each node you built, plus a runnodes shell script (or batch file on Windows).