Merge remote-tracking branch 'origin/master' into v0.2

.gitignore

@@ -12,4 +12,5 @@ substrate/pwasm-libc/Cargo.lock
 demo/runtime/wasm/target/
 **/._*
 .vscode
-polkadot.*
+polkadot.*
+.DS_Store

Cargo.toml

@@ -91,4 +91,5 @@ is-it-maintained-issue-resolution = { repository = "paritytech/polkadot" }
 is-it-maintained-open-issues = { repository = "paritytech/polkadot" }
 
 [profile.release]
-panic = "abort"
+# Substrate runtime requires unwinding.
+panic = "unwind" 

README.adoc

@@ -6,6 +6,7 @@
 
 Implementation of a https://polkadot.network node in Rust.
 
+
 == To play
 
 If you'd like to play with Polkadot, you'll need to install a client like this
@@ -46,6 +47,7 @@ polkadot --dev
 
 You can muck around by cloning and building the http://github.com/paritytech/polka-ui and http://github.com/paritytech/polkadot-ui or just heading to https://polkadot.js.org/apps.
 
+
 == Local Two-node Testnet
 
 If you want to see the multi-node consensus algorithm in action locally, then
@@ -62,6 +64,7 @@ polkadot --chain=local --validator --key Bob -d /tmp/bob --port 30334 --bootnode
 Ensure you replace `ALICE_BOOTNODE_ID_HERE` with the node ID from the output of
 the first terminal.
 
+
 == Hacking on Polkadot
 
 If you'd actually like hack on Polkadot, you can just grab the source code and
@@ -74,7 +77,7 @@ rustup update nightly
 rustup target add wasm32-unknown-unknown --toolchain nightly
 rustup update stable
 cargo install --git https://github.com/alexcrichton/wasm-gc
-sudo apt install cmake pkg-config libssl-dev
+sudo apt install cmake pkg-config libssl-dev git
 ----
 
 Then, grab the Polkadot source code:
@@ -103,4 +106,104 @@ You can start a development chain with:
 [source, shell]
 cargo run -- --dev
 
+
+== Using Docker
+
+=== The easiest way
+
+The easiest/faster option is to use the latest image.
+
+
+.First run
+Let´s first check the version we have. The first time you run this command, the polkadot docker image will be downloaded. This takes a bit of time and bandwidth, be patient:
+
+[source, shell]
+docker run --rm -it chevdor/polkadot:latest ./version
+
+
+.Polkadot arguments
+You can also pass any argument/flag that polkadot supports:
+
+[source, shell]
+docker run --rm -it chevdor/polkadot:latest polkadot --name "PolkaDocker"
+
+
+.Run as deamon
+Once you are done experimenting and picking the best node name :) you can start polkadot as daemon, exposes the polkadot ports and mount a volume that will keep your blockchain data locally:
+
+[source, shell]
+docker run -d -p 30333:30333 -p 9933:9933 -p 9944:9944 -v /my/local/folder:/data chevdor/polkadot:latest polkadot
+
+.Docker image update
+If you have an image such as `latest` locally, docker will *not* bother downloading the very latest that may be available.
+To update:
+
+- stop and delete your containers (`docker stop ...` `docker rm ...`)
+- delete your previous image (`docker rmi chevdor/polkadot:latest`)
+- run as daemon again, the very latest image will be downloaded again
+
+=== Build your own image
+
+To get up and running with the smallest footprint on your system, you may use the Polkadot Docker image.
+You can either build it yourself (it takes a while...):
+
+[source, shell]
+----
+ccd docker
+./build.sh
+----
+
+=== Reporting issues
+
+If you run into issues with polkadot when using docker, please run the following command
+(replace the tag with the appropriate one if you do not use latest):
+
+[source, shell]
+docker run --rm -it chevdor/polkadot:latest version
+
+This will show you the polkadot version as well as the git commit ref that was used to build your container.
+Just paste that in the issue you create.
+
+
+== Shell completion
+
+The Polkadot cli command supports shell auto-completion. For this to work, you will need to run the completion script matching you build and system.
+
+Assuming you built a release version using `cargo build --release` and use `bash` run the following:
+
+[source, shell]
+source target/release/completion-scripts/polkadot.bash
+
+You can find completion scripts for:
+- bash
+- fish
+- zsh
+- elvish
+- powershell
+
+To make this change persistent, you can proceed as follow:
+
+=== First install
+
+[source, shell]
+----
+COMPL_DIR=$HOME/.completion
+mkdir -p $COMPL_DIR
+cp -f target/release/completion-scripts/polkadot.bash $COMPL_DIR/
+echo "source $COMPL_DIR/polkadot.bash" >> $HOME/.bash_profile
+source $HOME/.bash_profile
+----
+
+=== Update
+
+When you build a new version of Polkadot, the following will ensure you auto-completion script matches the current binary:
+
+[source, shell]
+----
+COMPL_DIR=$HOME/.completion
+mkdir -p $COMPL_DIR
+cp -f target/release/completion-scripts/polkadot.bash $COMPL_DIR/
+source $HOME/.bash_profile
+----
+
 include::doc/packages.adoc[]

docker/Dockerfile

@@ -0,0 +1,33 @@
+FROM phusion/baseimage:0.10.1
+LABEL maintainer "chevdor@gmail.com"
+
+ARG PROFILE=release
+
+RUN mkdir -p polkadot && \
+	apt-get update && \
+	apt-get upgrade -y && \
+	apt-get install -y cmake pkg-config libssl-dev git && \
+	apt-get clean && \
+	mkdir -p /root/.local/share/Polkadot && \
+	ln -s /root/.local/share/Polkadot /data
+
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y && \
+	export PATH=$PATH:$HOME/.cargo/bin && \
+	rustup update nightly && \
+	rustup target add wasm32-unknown-unknown --toolchain nightly && \
+	rustup update stable && \
+	cargo install --git https://github.com/alexcrichton/wasm-gc && \
+	git clone https://github.com/paritytech/polkadot.git && \
+	cd polkadot && \
+	./build.sh && \
+	cargo build --$PROFILE && \
+	mv target/$PROFILE/polkadot /usr/local/bin && \
+	cargo clean && \
+	rm -rf /root/.cargo /root/.rustup /tmp/*
+
+COPY version /polkadot
+WORKDIR /polkadot
+EXPOSE 30333 9933 9944
+VOLUME ["/data"]
+
+CMD ["/bin/sh", "polkadot"]

docker/build.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -e
+
+# Find the current version from Cargo.toml
+VERSION=`grep "^version" ../Cargo.toml | egrep -o "([0-9\.]+)"`
+GITUSER=chevdor
+GITREPO=polkadot
+
+# Build the image
+echo "Building ${GITREPO}:$VERSION docker image, hang on!"
+time docker build --build-arg PROFILE=release -t ${GITUSER}/${GITREPO}:$VERSION .
+
+# Show the list of available images for this repo
+echo "Image is ready"
+docker images | grep ${GITREPO}
+
+echo -e "\nIf you just built the latest, you may want to update your tag:"
+echo " $ docker tag ${GITUSER}/${GITREPO}:$VERSION ${GITUSER}/${GITREPO}:latest"

docker/cleanup.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# This script helps reduce the size of the built image
+# It removes data that is not required.
+
+export PATH=$PATH:$HOME/.cargo/bin
+
+cargo clean
+rm -rf /root/.cargo /root/.rustup /tmp/*

docker/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3'
+services:
+  polkadot:
+    build:
+      context: .
+    ports:
+      - "127.0.0.1:30333:30333/tcp"
+      - "127.0.0.1:9933:9933/tcp"
+    image: chevdor/polkadot:latest
+    volumes:
+      - "polkadot-data:/data"
+    command: polkadot
+
+volumes:
+  polkadot-data:

docker/readme-docker.adoc

@@ -0,0 +1,16 @@
+
+== Polkadot Docker
+
+=== Start a Polkadot docker container
+
+Run the following command
+
+	docker run -d chevdor/polkadot:latest polkadot
+
+=== Building the image
+
+To build your own image from the source, you can run the following command:
+
+	./build.sh
+
+NOTE: Building the image takes a while. Count at least 30min on a good machine.

docker/version

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# This script show the polkadot version and commit ref that was
+# used to build the image.
+# If you report an issue, call this script to get all details.
+# This script will no longer be required once the polkadot cli
+# can report its commit ref.
+
+echo "-----------------------------------------"
+printf "Polkadot Docker Container: "
+polkadot --version
+printf " "
+git rev-parse HEAD
+echo "-----------------------------------------"

polkadot/cli/src/lib.rs

@@ -38,7 +38,7 @@ use chain_spec::ChainSpec;
 use futures::Future;
 use tokio::runtime::Runtime;
 pub use service::{Components as ServiceComponents, Service, CustomConfiguration};
-pub use cli::VersionInfo;
+pub use cli::{VersionInfo, IntoExit};
 
 fn load_spec(id: &str) -> Result<Option<service::ChainSpec>, String> {
 	Ok(match ChainSpec::from(id) {
@@ -51,22 +51,16 @@ fn load_spec(id: &str) -> Result<Option<service::ChainSpec>, String> {
 ///
 /// This will be invoked with the service and spawn a future that resolves
 /// when complete.
-pub trait Worker {
+pub trait Worker: IntoExit {
 	/// A future that resolves when the work is done or the node should exit.
 	/// This will be run on a tokio runtime.
 	type Work: Future<Item=(),Error=()> + Send + 'static;
 
-	/// An exit scheduled for the future.
-	type Exit: Future<Item=(),Error=()> + Send + 'static;
-
 	/// Return configuration for the polkadot node.
 	// TODO: make this the full configuration, so embedded nodes don't need
 	// string CLI args
 	fn configuration(&self) -> service::CustomConfiguration { Default::default() }
 
-	/// Don't work, but schedule an exit.
-	fn exit_only(&self) -> Self::Exit;
-
 	/// Do work and schedule exit.
 	fn work<C: service::Components>(self, service: &service::Service<C>) -> Self::Work;
 }
@@ -85,9 +79,9 @@ pub fn run<I, T, W>(args: I, worker: W, version: cli::VersionInfo) -> error::Res
 	W: Worker,
 {
 
-	match cli::prepare_execution::<service::Factory, _, _, _, _>(args, worker.exit_only(), version, load_spec, "parity-polkadot")? {
+	match cli::prepare_execution::<service::Factory, _, _, _, _>(args, worker, version, load_spec, "parity-polkadot")? {
 		cli::Action::ExecutedInternally => (),
-		cli::Action::RunService(mut config) => {
+		cli::Action::RunService((mut config, worker)) => {
 			info!("Parity ·:· Polkadot");
 			info!("  version {}", config.full_version());
 			info!("  by Parity Technologies, 2017, 2018");

polkadot/collator/src/lib.rs

@@ -69,7 +69,7 @@ use polkadot_api::PolkadotApi;
 use polkadot_primitives::{AccountId, BlockId, SessionKey};
 use polkadot_primitives::parachain::{self, BlockData, DutyRoster, HeadData, ConsolidatedIngress, Message, Id as ParaId};
 use polkadot_cli::{ServiceComponents, Service, CustomConfiguration, VersionInfo};
-use polkadot_cli::Worker;
+use polkadot_cli::{Worker, IntoExit};
 use tokio::timer::Deadline;
 
 const COLLATION_TIMEOUT: Duration = Duration::from_secs(30);
@@ -211,12 +211,21 @@ struct CollationNode<P, E> {
 	key: Arc<ed25519::Pair>,
 }
 
+impl<P, E> IntoExit for CollationNode<P, E> where
+	P: ParachainContext + Send + 'static,
+	E: Future<Item=(),Error=()> + Send + 'static
+{
+	type Exit = E;
+	fn into_exit(self) -> Self::Exit {
+		self.exit
+	}
+}
+
 impl<P, E> Worker for CollationNode<P, E> where
 	P: ParachainContext + Send + 'static,
-	E: Future<Item=(),Error=()> + Send + Clone + 'static
+	E: Future<Item=(),Error=()> + Send + 'static
 {
 	type Work = Box<Future<Item=(),Error=()> + Send>;
-	type Exit = E;
 
 	fn configuration(&self) -> CustomConfiguration {
 		let mut config = CustomConfiguration::default();
@@ -227,10 +236,6 @@ impl<P, E> Worker for CollationNode<P, E> where
 		config
 	}
 
-	fn exit_only(&self) -> Self::Exit {
-		self.exit.clone()
-	}
-
 	fn work<C: ServiceComponents>(self, service: &Service<C>) -> Self::Work {
 		let CollationNode { parachain_context, exit, para_id, key } = self;
 		let client = service.client();

polkadot/src/main.rs

@@ -38,11 +38,9 @@ mod vergen {
 
 // the regular polkadot worker simply does nothing until ctrl-c
 struct Worker;
-impl cli::Worker for Worker {
-	type Work = Self::Exit;
+impl cli::IntoExit for Worker {
 	type Exit = future::MapErr<oneshot::Receiver<()>, fn(oneshot::Canceled) -> ()>;
-
-	fn exit_only(&self) -> Self::Exit {
+	fn into_exit(self) -> Self::Exit {
 		// can't use signal directly here because CtrlC takes only `Fn`.
 		let (exit_send, exit) = oneshot::channel();
 
@@ -55,9 +53,13 @@ impl cli::Worker for Worker {
 
 		exit.map_err(drop)
 	}
+}
 
-	fn work<C: ServiceComponents>(self, _service: &Service<C>) -> Self::Exit {
-		self.exit_only()
+impl cli::Worker for Worker {
+	type Work = <Self as cli::IntoExit>::Exit;
+	fn work<C: ServiceComponents>(self, _service: &Service<C>) -> Self::Work {
+		use cli::IntoExit;
+		self.into_exit()
 	}
 }