Dump genesis to JSON file

Cargo.toml

@@ -23,6 +23,7 @@ members = [
 	"polkadot/runtime",
 	"polkadot/service",
 	"polkadot/statement-table",
+	"polkadot/telemetry",
 	"polkadot/transaction-pool",
 	"substrate/bft",
 	"substrate/client",

polkadot/telemetry/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "polkadot-telemetry"
+version = "0.2.0"
+authors = ["Parity Technologies <[email protected]>"]
+description = "Telemetry utils"
+
+[dependencies]
+parking_lot = "0.4"
+lazy_static = "1.0"
+slog = "^2"
+slog-json = "^2"
+slog-async = "^2"
+slog-scope = "*"
+websocket = "*"

polkadot/telemetry/src/lib.rs

@@ -0,0 +1,114 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Telemtetry utils.
+//! 
+//! `telemetry` macro be used from whereever in the Polkadot codebase
+//! in order to send real-time logging information to the telemetry
+//! server (if there is one). We use the async drain adapter of `slog`
+//! so that the logging thread doesn't get held up at all.
+
+extern crate parking_lot;
+extern crate websocket as ws;
+extern crate slog_async;
+extern crate slog_json;
+#[macro_use(o, kv)]
+extern crate slog;
+extern crate slog_scope;
+
+use std::io;
+use parking_lot::Mutex;
+use slog::Drain;
+pub use slog_scope::with_logger;
+
+/// Configuration for telemetry.
+pub struct TelemetryConfig {
+	/// URL of the telemetry WS server.
+	pub url: String,
+	/// What do do when we connect to the server.
+	pub on_connect: Box<Fn() + Send + 'static>,
+}
+
+/// Initialise telemetry.
+pub fn init_telemetry(config: TelemetryConfig) -> slog_scope::GlobalLoggerGuard {
+	let log = slog::Logger::root(
+		slog_async::Async::new(
+			slog_json::Json::default(
+				TelemetryWriter {
+					buffer: vec![],
+					out: Mutex::new(
+						ws::ClientBuilder::new(&config.url).ok().and_then(|mut x| x.connect(None).ok())
+					),
+					config,
+					first_time: true,	// ensures that on_connect will be called.
+				}
+			).fuse()
+		).build().fuse(), o!()
+	);
+	slog_scope::set_global_logger(log)
+}
+
+/// Exactly equivalent to `slog_scope::info`, provided as a convenience.
+#[macro_export]
+macro_rules! telemetry {
+	( $($t:tt)* ) => { $crate::with_logger(|l| slog_info!(l, $($t)* )) }
+}
+
+struct TelemetryWriter {
+	buffer: Vec<u8>,
+	out: Mutex<Option<ws::sync::Client<Box<ws::stream::sync::NetworkStream + Send>>>>,
+	config: TelemetryConfig,
+	first_time: bool,
+}
+
+impl TelemetryWriter {
+	fn ensure_connected(&mut self) {
+		if self.first_time {
+			(self.config.on_connect)();
+			self.first_time = false;
+		}
+		let mut client = self.out.lock();
+		if client.is_none() {
+			*client = ws::ClientBuilder::new(&self.config.url).ok().and_then(|mut x| x.connect(None).ok());
+			drop(client);
+			(self.config.on_connect)();
+		}
+	}
+}
+
+impl io::Write for TelemetryWriter {
+	fn write(&mut self, msg: &[u8]) -> io::Result<usize> {
+		if msg == b"\n" {
+			let _ = self.flush();
+		} else {
+			self.buffer.extend_from_slice(msg);
+		}
+		Ok(msg.len())
+	}
+
+	fn flush(&mut self) -> io::Result<()> {
+		self.ensure_connected();
+		if if let Some(ref mut socket) = *self.out.lock() {
+			if let Ok(s) = ::std::str::from_utf8(&self.buffer[..]) {
+				socket.send_message(&ws::Message::text(s)).is_err()
+			} else { false }
+		} else { false } {
+			*self.out.lock() = None;
+		}
+		self.buffer.clear();
+		Ok(())
+	}
+}

substrate/network/Cargo.toml

@@ -29,9 +29,9 @@ substrate-serializer = { path = "../../substrate/serializer" }
 substrate-runtime-support = { path = "../../substrate/runtime-support" }
 substrate-runtime-primitives = { path = "../../substrate/runtime/primitives" }
 substrate-bft = { path = "../../substrate/bft" }
+substrate-codec = { path = "../../substrate/codec" }
 
 [dev-dependencies]
 env_logger = "0.4"
-substrate-codec = { path = "../../substrate/codec" }
 substrate-keyring = { path = "../../substrate/keyring" }
 substrate-test-client = { path = "../../substrate/test-client" }

substrate/network/src/lib.rs

@@ -32,6 +32,7 @@ extern crate substrate_client as client;
 extern crate substrate_runtime_support as runtime_support;
 extern crate substrate_runtime_primitives as runtime_primitives;
 extern crate substrate_bft;
+extern crate substrate_codec as codec;
 extern crate serde;
 extern crate serde_json;
 extern crate futures;
@@ -42,7 +43,6 @@ extern crate ed25519;
 #[macro_use] extern crate error_chain;
 
 #[cfg(test)] extern crate env_logger;
-#[cfg(test)] extern crate substrate_codec as codec;
 #[cfg(test)] extern crate substrate_keyring as keyring;
 #[cfg(test)] extern crate substrate_test_client as test_client;
 

substrate/network/src/message.rs

@@ -19,7 +19,7 @@
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT};
 use service::Role as RoleFlags;
 
-pub use self::generic::{BlockAnnounce, RemoteCallRequest, ConsensusVote, SignedConsensusVote, FromBlock};
+pub use self::generic::{BlockAnnounce, RemoteCallRequest, ConsensusVote, SignedConsensusVote, FromBlock, Body};
 
 pub type RequestId = u64;
 
@@ -171,10 +171,37 @@ pub struct RemoteCallResponse {
 /// Generic types.
 pub mod generic {
 	use primitives::AuthorityId;
+	use codec::Slicable;
 	use runtime_primitives::bft::Justification;
 	use ed25519;
 
 	use super::{Role, BlockAttribute, RemoteCallResponse, RequestId, Transactions, Direction};
+
+	use primitives::bytes;
+	#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+	pub struct V1Extrinsic(#[serde(with="bytes")] pub Vec<u8>);
+	// Alternative block format for poc-1 compatibility.
+	// TODO: remove this after poc-2
+	#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+	#[serde(untagged)]
+	pub enum Body<Extrinsic> {
+		V1(Vec<V1Extrinsic>),
+		Extrinsics(Vec<Extrinsic>),
+	}
+
+	impl<Extrinsic> Body<Extrinsic> where Extrinsic: Slicable {
+		pub fn to_extrinsics(self) -> Vec<Extrinsic> {
+			match self {
+				Body::Extrinsics(e) => e,
+				Body::V1(e) => {
+					e.into_iter().filter_map(|bytes|
+						Slicable::decode(&mut bytes.0.as_slice())
+					).collect()
+				}
+			}
+		}
+	}
+
 	/// Block data sent in the response.
 	#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 	pub struct BlockData<Header, Hash, Extrinsic> {
@@ -183,7 +210,7 @@ pub mod generic {
 		/// Block header if requested.
 		pub header: Option<Header>,
 		/// Block body if requested.
-		pub body: Option<Vec<Extrinsic>>,
+		pub body: Option<Body<Extrinsic>>,
 		/// Block receipt if requested.
 		pub receipt: Option<Vec<u8>>,
 		/// Block message queue if requested.

substrate/network/src/protocol.rs

@@ -262,7 +262,7 @@ impl<B: BlockT> Protocol<B> where
 			let block_data = message::generic::BlockData {
 				hash: hash,
 				header: if get_header { Some(header) } else { None },
-				body: if get_body { self.chain.body(&BlockId::Hash(hash)).unwrap_or(None) } else { None },
+				body: (if get_body { self.chain.body(&BlockId::Hash(hash)).unwrap_or(None) } else { None }).map(|body| message::Body::Extrinsics(body)),
 				receipt: None,
 				message_queue: None,
 				justification: if get_justification { self.chain.justification(&BlockId::Hash(hash)).unwrap_or(None) } else { None },

substrate/network/src/sync.rs

@@ -257,7 +257,7 @@ impl<B: BlockT> ChainSync<B> where
 						is_best,
 						header,
 						justification,
-						block.body
+						block.body.map(|b| b.to_extrinsics()),
 					);
 					match result {
 						Ok(ImportResult::AlreadyInChain) => {