Merge branch 'master' into td-logging

Author: tomusdrw

Cargo.lock

@@ -103,6 +103,7 @@ members = [
 	"srml/staking/reward-curve",
 	"srml/sudo",
 	"srml/system",
+	"srml/system/rpc",
 	"srml/timestamp",
 	"srml/treasury",
 	"srml/utility",

Cargo.toml

@@ -20,6 +20,7 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fs::File;
 use std::path::PathBuf;
+use std::rc::Rc;
 use serde::{Serialize, Deserialize};
 use primitives::storage::{StorageKey, StorageData};
 use sr_primitives::{BuildStorage, StorageOverlay, ChildrenStorageOverlay};
@@ -31,15 +32,15 @@ use tel::TelemetryEndpoints;
 enum GenesisSource<G> {
 	File(PathBuf),
 	Binary(Cow<'static, [u8]>),
-	Factory(fn() -> G),
+	Factory(Rc<dyn Fn() -> G>),
 }
 
 impl<G> Clone for GenesisSource<G> {
 	fn clone(&self) -> Self {
 		match *self {
 			GenesisSource::File(ref path) => GenesisSource::File(path.clone()),
 			GenesisSource::Binary(ref d) => GenesisSource::Binary(d.clone()),
-			GenesisSource::Factory(f) => GenesisSource::Factory(f),
+			GenesisSource::Factory(ref f) => GenesisSource::Factory(f.clone()),
 		}
 	}
 }
@@ -187,10 +188,10 @@ impl<G, E> ChainSpec<G, E> {
 	}
 
 	/// Create hardcoded spec.
-	pub fn from_genesis(
+	pub fn from_genesis<F: Fn() -> G + 'static>(
 		name: &str,
 		id: &str,
-		constructor: fn() -> G,
+		constructor: F,
 		boot_nodes: Vec<String>,
 		telemetry_endpoints: Option<TelemetryEndpoints>,
 		protocol_id: Option<&str>,
@@ -211,7 +212,7 @@ impl<G, E> ChainSpec<G, E> {
 
 		ChainSpec {
 			spec,
-			genesis: GenesisSource::Factory(constructor),
+			genesis: GenesisSource::Factory(Rc::new(constructor)),
 		}
 	}
 }

core/chain-spec/src/chain_spec.rs

@@ -1059,10 +1059,10 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 					}
 				};
 
-				let encoded_block = <Block as BlockT>::new(
-					import_headers.pre().clone(),
-					body.unwrap_or_default(),
-				).encode();
+				let encoded_block = <Block as BlockT>::encode_from(
+					import_headers.pre(),
+					&body.unwrap_or_default()
+				);
 
 				let (_, storage_update, changes_update) = self.executor
 					.call_at_state::<_, _, NeverNativeValue, fn() -> _>(

core/client/src/client.rs

@@ -99,6 +99,12 @@ impl From<String> for Error {
 	}
 }
 
+impl From<WasmError> for Error {
+	fn from(err: WasmError) -> Error {
+		Error::Other(err.to_string())
+	}
+}
+
 /// Type for errors occurring during Wasm runtime construction.
 #[derive(Debug, derive_more::Display)]
 pub enum WasmError {

core/executor/src/error.rs

@@ -50,6 +50,33 @@ pub use primitives::traits::Externalities;
 pub use wasm_interface;
 pub use wasm_runtime::WasmExecutionMethod;
 
+/// Call the given `function` in the given wasm `code`.
+///
+/// The signature of `function` needs to follow the default Substrate function signature.
+///
+/// - `call_data`: Will be given as input parameters to `function`
+/// - `execution_method`: The execution method to use.
+/// - `ext`: The externalities that should be set while executing the wasm function.
+/// - `heap_pages`: The number of heap pages to allocate.
+///
+/// Returns the `Vec<u8>` that contains the return value of the function.
+pub fn call_in_wasm<E: Externalities>(
+	function: &str,
+	call_data: &[u8],
+	execution_method: WasmExecutionMethod,
+	ext: &mut E,
+	code: &[u8],
+	heap_pages: u64,
+) -> error::Result<Vec<u8>> {
+	let mut instance = wasm_runtime::create_wasm_runtime_with_code(
+		ext,
+		execution_method,
+		heap_pages,
+		code,
+	)?;
+	instance.call(ext, function, call_data)
+}
+
 /// Provides runtime information.
 pub trait RuntimeInfo {
 	/// Native runtime information.
@@ -61,3 +88,24 @@ pub trait RuntimeInfo {
 		ext: &mut E,
 	) -> Option<RuntimeVersion>;
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use runtime_test::WASM_BINARY;
+	use runtime_io::TestExternalities;
+
+	#[test]
+	fn call_in_interpreted_wasm_works() {
+		let mut ext = TestExternalities::default();
+		let res = call_in_wasm(
+			"test_empty_return",
+			&[],
+			WasmExecutionMethod::Interpreted,
+			&mut ext,
+			&WASM_BINARY,
+			8,
+		).unwrap();
+		assert_eq!(res, vec![0u8; 0]);
+	}
+}

core/executor/src/lib.rs

@@ -157,17 +157,27 @@ impl RuntimesCache {
 	}
 }
 
-fn create_wasm_runtime<E: Externalities>(
+/// Create a wasm runtime with the given `code`.
+pub fn create_wasm_runtime_with_code<E: Externalities>(
 	ext: &mut E,
 	wasm_method: WasmExecutionMethod,
 	heap_pages: u64,
+	code: &[u8],
 ) -> Result<Box<dyn WasmRuntime>, WasmError> {
-	let code = ext
-		.original_storage(well_known_keys::CODE)
-		.ok_or(WasmError::CodeNotFound)?;
 	match wasm_method {
 		WasmExecutionMethod::Interpreted =>
-			wasmi_execution::create_instance(ext, &code, heap_pages)
+			wasmi_execution::create_instance(ext, code, heap_pages)
 				.map(|runtime| -> Box<dyn WasmRuntime> { Box::new(runtime) }),
 	}
 }
+
+fn create_wasm_runtime<E: Externalities>(
+	ext: &mut E,
+	wasm_method: WasmExecutionMethod,
+	heap_pages: u64,
+) -> Result<Box<dyn WasmRuntime>, WasmError> {
+	let code = ext
+		.original_storage(well_known_keys::CODE)
+		.ok_or(WasmError::CodeNotFound)?;
+	create_wasm_runtime_with_code(ext, wasm_method, heap_pages, &code)
+}

core/executor/src/wasm_runtime.rs

@@ -50,6 +50,14 @@ pub struct Health {
 	pub should_have_peers: bool,
 }
 
+impl fmt::Display for Health {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		write!(fmt, "{} peers ({})", self.peers, if self.is_syncing {
+			"syncing"
+		} else { "idle" })
+	}
+}
+
 /// Network Peer information
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -66,12 +74,17 @@ pub struct PeerInfo<Hash, Number> {
 	pub best_number: Number,
 }
 
-impl fmt::Display for Health {
-	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-		write!(fmt, "{} peers ({})", self.peers, if self.is_syncing {
-			"syncing"
-		} else { "idle" })
-	}
+/// The role the node is running as
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub enum NodeRole {
+	/// The node is a full node
+	Full,
+	/// The node is a light client
+	LightClient,
+	/// The node is an authority
+	Authority,
+	/// An unknown role with a bit number
+	UnknownRole(u8)
 }
 
 #[cfg(test)]

core/rpc/api/src/system/helpers.rs

@@ -24,7 +24,7 @@ use jsonrpc_derive::rpc;
 
 use self::error::Result;
 
-pub use self::helpers::{Properties, SystemInfo, Health, PeerInfo};
+pub use self::helpers::{Properties, SystemInfo, Health, PeerInfo, NodeRole};
 pub use self::gen_client::Client as SystemClient;
 
 /// Substrate system RPC API
@@ -64,4 +64,8 @@ pub trait SystemApi<Hash, Number> {
 	// TODO: make this stable and move structs https://github.com/paritytech/substrate/issues/1890
 	#[rpc(name = "system_networkState", returns = "jsonrpc_core::Value")]
 	fn system_network_state(&self) -> Receiver<jsonrpc_core::Value>;
+
+	/// Returns the roles the node is running as.
+	#[rpc(name = "system_nodeRoles", returns = "Vec<NodeRole>")]
+	fn system_node_roles(&self) -> Receiver<Vec<NodeRole>>;
 }

core/rpc/api/src/system/mod.rs

@@ -282,7 +282,7 @@ fn should_return_runtime_version() {
 		\"specVersion\":1,\"implVersion\":1,\"apis\":[[\"0xdf6acb689907609b\",2],\
 		[\"0x37e397fc7c91f5e4\",1],[\"0xd2bc9897eed08f15\",1],[\"0x40fe3ad401f8959a\",3],\
 		[\"0xc6e9a76309f39b09\",1],[\"0xdd718d5cc53262d4\",1],[\"0xcbca25e39f142387\",1],\
-		[\"0xf78b278be53f454c\",1],[\"0xab3c0572291feb8b\",1]]}";
+		[\"0xf78b278be53f454c\",1],[\"0xab3c0572291feb8b\",1],[\"0xbc9d89904f5b923f\",1]]}";
 
 	let runtime_version = api.runtime_version(None.into()).wait().unwrap();
 	let serialized = serde_json::to_string(&runtime_version).unwrap();

core/rpc/src/state/tests.rs

@@ -25,7 +25,7 @@ use sr_primitives::traits::{self, Header as HeaderT};
 use self::error::Result;
 
 pub use api::system::*;
-pub use self::helpers::{Properties, SystemInfo, Health, PeerInfo};
+pub use self::helpers::{Properties, SystemInfo, Health, PeerInfo, NodeRole};
 pub use self::gen_client::Client as SystemClient;
 
 /// System API implementation
@@ -42,6 +42,8 @@ pub enum Request<B: traits::Block> {
 	Peers(oneshot::Sender<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>),
 	/// Must return the state of the network.
 	NetworkState(oneshot::Sender<rpc::Value>),
+	/// Must return the node role.
+	NodeRoles(oneshot::Sender<Vec<NodeRole>>)
 }
 
 impl<B: traits::Block> System<B> {
@@ -94,4 +96,10 @@ impl<B: traits::Block> SystemApi<B::Hash, <B::Header as HeaderT>::Number> for Sy
 		let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
 		Receiver(Compat::new(rx))
 	}
+
+	fn system_node_roles(&self) -> Receiver<Vec<NodeRole>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NodeRoles(tx));
+		Receiver(Compat::new(rx))
+	}
 }

core/rpc/src/system/mod.rs

@@ -79,6 +79,9 @@ fn api<T: Into<Option<Status>>>(sync: T) -> System<Block> {
 						average_upload_per_sec: 0,
 						peerset: serde_json::Value::Null,
 					}).unwrap());
+				},
+				Request::NodeRoles(sender) => {
+					let _ = sender.send(vec![NodeRole::Authority]);
 				}
 			};
 
@@ -221,3 +224,11 @@ fn system_network_state() {
 		}
 	);
 }
+
+#[test]
+fn system_node_roles() {
+	assert_eq!(
+		wait_receiver(api(None).system_node_roles()),
+		vec![NodeRole::Authority]
+	);
+}

core/rpc/src/system/tests.rs

@@ -368,6 +368,7 @@ macro_rules! new_impl {
 
 
 		let _ = to_spawn_tx.unbounded_send(Box::new(build_network_future(
+			$config.roles,
 			network_mut,
 			client.clone(),
 			network_status_sinks.clone(),
@@ -662,14 +663,15 @@ fn build_network_future<
 	S: network::specialization::NetworkSpecialization<B>,
 	H: network::ExHashT
 > (
+	roles: Roles,
 	mut network: network::NetworkWorker<B, S, H>,
 	client: Arc<C>,
 	status_sinks: Arc<Mutex<Vec<mpsc::UnboundedSender<(NetworkStatus<B>, NetworkState)>>>>,
 	rpc_rx: futures03::channel::mpsc::UnboundedReceiver<rpc::system::Request<B>>,
 	should_have_peers: bool,
 	dht_event_tx: Option<mpsc::Sender<DhtEvent>>,
 ) -> impl Future<Item = (), Error = ()> {
-	// Compatibility shim while we're transitionning to stable Futures.
+	// Compatibility shim while we're transitioning to stable Futures.
 	// See https://github.com/paritytech/substrate/issues/3099
 	let mut rpc_rx = futures03::compat::Compat::new(rpc_rx.map(|v| Ok::<_, ()>(v)));
 
@@ -725,6 +727,21 @@ fn build_network_future<
 						let _ = sender.send(network_state);
 					}
 				}
+				rpc::system::Request::NodeRoles(sender) => {
+					use rpc::system::NodeRole;
+
+					let node_roles = (0 .. 8)
+						.filter(|&bit_number| (roles.bits() >> bit_number) & 1 == 1)
+						.map(|bit_number| match Roles::from_bits(1 << bit_number) {
+							Some(Roles::AUTHORITY) => NodeRole::Authority,
+							Some(Roles::LIGHT) => NodeRole::LightClient,
+							Some(Roles::FULL) => NodeRole::Full,
+							_ => NodeRole::UnknownRole(bit_number),
+						})
+						.collect();
+
+					let _ = sender.send(node_roles);
+				}
 			};
 		}
 

core/service/src/lib.rs

@@ -94,6 +94,9 @@ where
 	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self {
 		Block { header, extrinsics }
 	}
+	fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8> {
+		(header, extrinsics).encode()
+	}
 }
 
 /// Abstraction over a substrate block and justification.

core/sr-primitives/src/generic/block.rs

@@ -259,6 +259,9 @@ impl<Xt: 'static + Codec + Sized + Send + Sync + Serialize + Clone + Eq + Debug
 	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self {
 		Block { header, extrinsics }
 	}
+	fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8> {
+		(header, extrinsics).encode()
+	}
 }
 
 impl<'a, Xt> Deserialize<'a> for Block<Xt> where Block<Xt>: Decode {

core/sr-primitives/src/testing.rs

@@ -684,6 +684,8 @@ pub trait Block: Clone + Send + Sync + Codec + Eq + MaybeSerialize + Debug + 'st
 	fn hash(&self) -> Self::Hash {
 		<<Self::Header as Header>::Hashing as Hash>::hash_of(self.header())
 	}
+	/// Create an encoded block from the given `header` and `extrinsics` without requiring to create an instance.
+	fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8>;
 }
 
 /// Something that acts like an `Extrinsic`.

core/sr-primitives/src/traits.rs

@@ -31,6 +31,7 @@ cfg-if = "0.1.10"
 srml-babe = { path = "../../srml/babe", default-features = false }
 srml-timestamp = { path = "../../srml/timestamp", default-features = false }
 srml-system = { path = "../../srml/system", default-features = false }
+srml-system-rpc-runtime-api = { path = "../../srml/system/rpc/runtime-api", default-features = false }
 
 [dev-dependencies]
 substrate-executor = { path = "../executor" }
@@ -68,6 +69,7 @@ std = [
 	"srml-babe/std",
 	"srml-timestamp/std",
 	"srml-system/std",
+	"srml-system-rpc-runtime-api/std",
 	"app-crypto/std",
 	"session/std",
 ]