Wrap master node in docker container

.gitignore

@@ -7,6 +7,7 @@ target/
 # IntelliJ
 .idea
 .vscode
+*.iml
 
 # MacOS folder metadata
 .DS_Store

.travis.yml

@@ -7,7 +7,8 @@ matrix:
       services:
         - docker
       install:
-        - docker pull fluencelabs/solver:latest
+        - docker pull fluencelabs/solver:2018-dec-demo
+        - docker pull fluencelabs/node:2018-dec-demo
 
       # These directories are cached to S3 at the end of the build
       cache:

bootstrap/README.md

@@ -21,4 +21,7 @@ Then, copy & paste contract's address and your wallet into `ContractSpec` and ru
 `npm run ganache`
 
 ## Run tests
-`npm test`
+`npm test`
+
+## Get current eth account through truffle
+`npm run getEthAccount`

bootstrap/package.json

@@ -8,7 +8,8 @@
   "scripts": {
     "test": "truffle test",
     "migrate": "truffle migrate",
-    "ganache": "ganache-cli -m \"indicate toward book great daring meat tooth bid finger banana witness episode\" &",
+    "ganache": "ganache-cli -m \"indicate toward book great daring meat tooth bid finger banana witness episode\" -h 0.0.0.0 &",
+    "getEthAccount": "echo 'web3.eth.accounts[0]' | truffle console | grep -o \"0x.*\" | tr -d \\'",
     "generate-java-wrapper": "scripts/generate_java_wrapper.sh",
     "compile-sol": "node scripts/compile_sol.js",
     "generate-all": "npm run compile-sol && npm run generate-java-wrapper"

build.sbt

@@ -113,20 +113,22 @@ lazy val statemachine = (project in file("statemachine"))
       "net.i2p.crypto"         % "eddsa"          % "0.3.0",
       scalaTest
     ),
+    assemblyJarName in assembly := "statemachine.jar",
     assemblyMergeStrategy in assembly := {
       // a module definition fails compilation for java 8, just skip it
       case PathList("module-info.class", xs @ _*) => MergeStrategy.first
       case x =>
         val oldStrategy = (assemblyMergeStrategy in assembly).value
         oldStrategy(x)
     },
+    test in assembly := {},
     imageNames in docker := Seq(ImageName("fluencelabs/solver")),
     dockerfile in docker := {
       // Run `sbt docker` to create image
 
       // The assembly task generates a fat JAR file
-      val artifact: File = assembly.value
-      val artifactTargetPath = s"/app/${artifact.name}"
+      val artifact = assembly.value
+      val artifactTargetPath = s"/${artifact.name}"
 
       // Tendermint constants
       val tmVersion = "0.25.0"
@@ -145,11 +147,9 @@ lazy val statemachine = (project in file("statemachine"))
       val vmDataRoot = "/vmcode"
 
       new Dockerfile {
-        from("xqdocker/ubuntu-openjdk:jre-8")
-        run("apt", "-yqq", "update")
-        run("apt", "-yqq", "install", "wget", "curl", "jq", "unzip", "screen")
-        run("wget", tmBinaryUrl)
-        run("unzip", "-d", "/bin", tmBinaryArchive)
+        from("openjdk:8-jre-alpine")
+        // TODO: merge all these `run`s into a single run
+        runRaw(s"wget $tmBinaryUrl && unzip -d /bin $tmBinaryArchive && rm $tmBinaryArchive")
 
         expose(tmP2pPort)
         expose(tmRpcPort)
@@ -163,9 +163,9 @@ lazy val statemachine = (project in file("statemachine"))
         // includes solver run script and default configs in the image
         copy(baseDirectory.value / "docker" / "solver", solverDataRoot)
 
-        add(artifact, artifactTargetPath)
+        copy(artifact, artifactTargetPath)
 
-        entryPoint("bash", solverRunScript, tmDataRoot, solverDataRoot, artifactTargetPath)
+        entryPoint("sh", solverRunScript, artifactTargetPath)
       }
     }
   )
@@ -224,7 +224,48 @@ lazy val node = project
       circeGeneric,
       circeParser,
       scalaTest
-    )
+    ),
+    assemblyMergeStrategy in assembly := {
+      // a module definition fails compilation for java 8, just skip it
+      case PathList("module-info.class", xs @ _*) => MergeStrategy.first
+      case "META-INF/io.netty.versions.properties" =>
+        MergeStrategy.first
+      case x =>
+        val oldStrategy = (assemblyMergeStrategy in assembly).value
+        oldStrategy(x)
+    },
+    mainClass in assembly := Some("fluence.node.MasterNodeApp"),
+    assemblyJarName in assembly := "master-node.jar",
+    test in assembly := {},
+    imageNames in docker := Seq(ImageName("fluencelabs/node")),
+    dockerfile in docker := {
+      // The assembly task generates a fat JAR file
+      val artifact: File = assembly.value
+      val artifactTargetPath = s"/${artifact.name}"
+
+      new Dockerfile {
+        // docker is needed in image so it can connect to host's docker.sock and run solvers on host
+        val dockerBinary = "https://download.docker.com/linux/static/stable/x86_64/docker-18.06.1-ce.tgz"
+        from("openjdk:8-jre-alpine")
+        runRaw(s"wget -q $dockerBinary -O- | tar -C /usr/bin/ -zxv docker/docker --strip-components=1")
+
+        volume("/master") // anonymous volume to store all data
+
+        /*
+        * The following directory structure is assumed in node/src/main/resources:
+        *    docker/
+        *      tendermint/config/default_config.toml
+        *      vmcode/vmcode-llamadb/llama_db.wasm
+        *    entrypoint.sh
+        */
+        copy((resourceDirectory in Compile).value / "docker", "/master/")
+
+        copy(artifact, artifactTargetPath)
+
+        cmd("java", "-jar", artifactTargetPath)
+        entryPoint("sh", "/master/entrypoint.sh")
+      }
+    }
   )
-  .enablePlugins(AutomateHeaderPlugin)
+  .enablePlugins(AutomateHeaderPlugin, DockerPlugin)
   .dependsOn(ethclient, externalstorage)

cli/src/publisher.rs

@@ -94,7 +94,7 @@ impl Publisher {
             let receipt: H256 =
                 "0000000000000000000000000000000000000000000000000000000000000000".parse()?;
 
-            let options = utils::options_with_gas(500_000);
+            let options = utils::options_with_gas(2_000_000);
 
             utils::call_contract(
                 self.account,

node/README.md

@@ -0,0 +1,57 @@
+## How to run ganache
+In order to run master node, you need to have any Ethereum RPC node. In this example we will use Ganache for that purpose. To run Ganache and deploy Fluence contract there, run
+```
+cd fluence/bootstrap
+
+npm install
+npm run ganache
+npm run migrate
+```
+
+You will see address of the Deployer contract in your private Ganache blockchain:
+```
+Deployer: 0x9995882876ae612bfd829498ccd73dd962ec950a
+```
+
+Ganache is run in deterministic mode with predefined mnemonic, so this address will always be the same and there is no need to save it.
+
+## How to run master node
+Go to `fluence/tools/node` and run `docker-compose`:
+```
+cd fluence/tools/node
+
+docker-compose -f single-master.yml up -dV
+```
+
+`single-master.yml` runs one Swarm container and one master node container with solver ports 25000-25003.
+
+## How to run solvers
+
+After having run master node, you need to upload and publish your WASM code to Swarm. In this example we will use `llamadb` that can be found at `fluence/node/src/main/resources/docker/vmcode/vmcode-llamadb/llama_db.wasm`. You can use Fluence `cli` to upload and publish it:
+```
+cd fluence/cli
+
+cargo build --release
+
+target/release/fluence publish ../node/src/main/resources/docker/vmcode/vmcode-llamadb/llama_db.wasm 0x9995882876ae612bfd829498ccd73dd962ec950a 0x4180fc65d613ba7e1a385181a219f1dbfe7bf11d --cluster_size 1
+```
+
+You can take a look at `target/release/fluence publish --help` to get the idea of how it works. I will describe parameters briefly:
+
+- `target/release/fluence` is a `cli` binary we compiled by running `cargo build --release`
+- `publish` is a command that uploads code to Swarm and sends it to Ethereum contract (running on Ganache)
+- `../node/src/main/resources/docker/vmcode/vmcode-llamadb/llama_db.wasm` is a path to llamadb compiled to WASM
+- `0x9995882876ae612bfd829498ccd73dd962ec950a` is a Deployer contract address that was deployed by `npm run migrate`
+- `0x4180fc65d613ba7e1a385181a219f1dbfe7bf11d` is an Ethereum account address that's used for publishing code
+- `--cluster_size 1` specifies number of nodes required to run this code. We ran single master node, so we specify 1 here.
+
+## How to check solver is running fine
+You can check solver's logs by issuing `docker logs 01_node0` (you may need to replace `01_node0` with the name of the solver container, see `docker ps`). Look for `Commit: processTime=23 height=2`, `processTime` could be anything, you're looking for `height=2`. It can appear after some time, usually 10-60 seconds, depending on your hardware.
+
+## Cleaning up
+- To clean up ALL docker containers, including volumes: `docker ps -a | awk '{print $1}' | xargs docker rm -f ; docker volume prune -f`
+- To clean up docker-compose state: `docker-compose -f single-master.yml kill`
+- To stop ganache: `pkill -f ganache`
+
+## Troubleshooting
+TODO

node/src/main/resources/docker/entrypoint.sh

@@ -0,0 +1,83 @@
+# Copyright 2018 Fluence Labs Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#!/usr/bin/env bash -e
+
+###
+# This script is an entrypoint of the Master docker container.
+# It first checks that $TENDERMINT_IP and $PORTS are defined,
+# if /var/run/docker.sock is passed as a volume, and
+# then if running master-node.jar, generate application.conf,
+# and run whatever command is passed as arguments (usually it's CMD from Dockerfile).
+###
+
+# set to fail fast
+set -e
+
+if [ -z "$TENDERMINT_IP" ]; then
+  cat >&2 <<EOF
+error: \`-e "TENDERMINT_IP=your_external_ip"\` was not specified.
+It is required so Tendermint instance can advertise its address to cluster participants
+EOF
+  exit 1
+fi
+
+if [ -z "$PORTS" ]; then
+  cat >&2 <<EOF
+error: \`-e "PORTS=start:stop"\` was not specified.
+TODO: add more helpful explanation
+EOF
+  exit 1
+fi
+
+if [ ! -S /var/run/docker.sock ]; then
+    cat >&2 <<EOF
+error: '/var/run/docker.sock' not found in container or is not a socket.
+Please, pass it as a volume when running the container: \`-v /var/run/docker.sock:/var/run/docker.sock\`
+EOF
+exit 1
+fi
+
+if [ -z "$ETHEREUM_IP" ]; then
+    ETHEREUM_IP=$TENDERMINT_IP
+fi
+
+SWARM_ENABLED="true"
+if [ -z "$SWARM_IP" ]; then
+    SWARM_ENABLED="false"
+fi
+
+# Running master-node.jar, that means running default CMD
+if [ "$3" = "/master-node.jar" ]; then
+    CONTAINER_ID=$(cat /proc/1/cpuset)
+    cat > "/master/application.conf" <<EOF
+endpoints {
+  ip = "$TENDERMINT_IP"
+  min-port = ${PORTS%:*}
+  max-port = ${PORTS#*:}
+}
+ethereum {
+  host = "$ETHEREUM_IP"
+}
+swarm {
+  host = "$SWARM_IP"
+  enabled = "$SWARM_ENABLED"
+}
+tendermint-path = "/master"
+master-container-id = "${CONTAINER_ID#"/docker/"}"
+EOF
+fi
+
+# Execute whatever command is passed as arguments. Usually it's CMD from Dockerfile.
+exec "$@"

node/src/main/resources/reference.conf

@@ -1,16 +1,36 @@
 // a path to a working directory, where all keys, configurations and codes files will be stored
 tendermint-path = "target/.tendermint"
 
+solver {
+  image = "fluencelabs/solver"
+  tag = "2018-dec-demo"
+}
+
 endpoints {
   // IP address for all endpoints that will be used for solvers
   ip = "127.0.0.1"
   // ports that will be selected by the deployer smart contract
   min-port = 20000
   max-port = 20100
 }
+
+ethereum {
+  // ethereum RPC protocol
+  protocol = "http"
+
+  // ethereum RPC address
+  ip = "127.0.0.1"
+
+  // ethereum RPC port
+  port = 8545
+}
+
 // use the Swarm or run local precompiled code
-use-swarm: true,
+use-swarm: false,
 swarm {
   // the address to the Swarm gateway
-  host = "http://localhost:8500"
+  protocol = "http"
+  host = "localhost"
+  port = 8500
+  enabled = false
 }

node/src/main/scala/fluence/node/ConfigOps.scala

@@ -37,9 +37,7 @@ object ConfigOps {
           )
         )
       )
-
     }
-
   }
 
   implicit val inetAddressConvert: ConfigConvert[InetAddress] =